Test dev

examples/common/dbstore-update-server.py

@@ -0,0 +1,94 @@
+'''
+Pymodbus Server With Updating Thread
+--------------------------------------------------------------------------
+This is an example of having a background thread updating the
+context in an SQLite4 database while the server is operating.
+
+This scrit generates a random address range (within 0 - 65000) and a random
+value and stores it in a database. It then reads the same address to verify
+that the process works as expected
+
+This can also be done with a python thread::
+    from threading import Thread
+    thread = Thread(target=updating_writer, args=(context,))
+    thread.start()
+'''
+#---------------------------------------------------------------------------#
+# import the modbus libraries we need
+#---------------------------------------------------------------------------#
+from pymodbus.server.async import StartTcpServer
+from pymodbus.device import ModbusDeviceIdentification
+from pymodbus.datastore import ModbusSequentialDataBlock
+from pymodbus.datastore import ModbusServerContext
+from pymodbus.datastore.database import SqlSlaveContext
+from pymodbus.transaction import ModbusRtuFramer, ModbusAsciiFramer
+import random
+
+#---------------------------------------------------------------------------#
+# import the twisted libraries we need
+#---------------------------------------------------------------------------#
+from twisted.internet.task import LoopingCall
+
+#---------------------------------------------------------------------------#
+# configure the service logging
+#---------------------------------------------------------------------------#
+import logging
+logging.basicConfig()
+log = logging.getLogger()
+log.setLevel(logging.DEBUG)
+
+#---------------------------------------------------------------------------#
+# define your callback process
+#---------------------------------------------------------------------------#
+def updating_writer(a):
+    ''' A worker process that runs every so often and
+    updates live values of the context which resides in an SQLite3 database.
+    It should be noted that there is a race condition for the update.
+    :param arguments: The input arguments to the call
+    '''
+    log.debug("Updating the database context")
+    context  = a[0]
+    readfunction = 0x03 # read holding registers
+    writefunction = 0x10
+    slave_id = 0x01 # slave address
+    count = 50
+
+    # import pdb; pdb.set_trace()
+
+    rand_value = random.randint(0, 9999)
+    rand_addr = random.randint(0, 65000)
+    log.debug("Writing to datastore: {}, {}".format(rand_addr, rand_value))
+    # import pdb; pdb.set_trace()
+    context[slave_id].setValues(writefunction, rand_addr, [rand_value])
+    values = context[slave_id].getValues(readfunction, rand_addr, count)
+    log.debug("Values from datastore: " + str(values))
+
+
+
+#---------------------------------------------------------------------------#
+# initialize your data store
+#---------------------------------------------------------------------------#
+block = ModbusSequentialDataBlock(0x00, [0]*0xff)
+store = SqlSlaveContext(block)
+
+context = ModbusServerContext(slaves={1: store}, single=False)
+
+
+#---------------------------------------------------------------------------#
+# initialize the server information
+#---------------------------------------------------------------------------#
+identity = ModbusDeviceIdentification()
+identity.VendorName  = 'pymodbus'
+identity.ProductCode = 'PM'
+identity.VendorUrl   = 'http://github.com/bashwork/pymodbus/'
+identity.ProductName = 'pymodbus Server'
+identity.ModelName   = 'pymodbus Server'
+identity.MajorMinorRevision = '1.0'
+
+#---------------------------------------------------------------------------#
+# run the server you want
+#---------------------------------------------------------------------------#
+time = 5 # 5 seconds delay
+loop = LoopingCall(f=updating_writer, a=(context,))
+loop.start(time, now=False) # initially delay by time
+StartTcpServer(context, identity=identity, address=("", 5020))

examples/contrib/message-generator.py

@@ -12,6 +12,7 @@
 * binary - `./generate-messages.py -f binary -m tx -b`
 '''
 from optparse import OptionParser
+import codecs as c
 #--------------------------------------------------------------------------#
 # import all the available framers
 #--------------------------------------------------------------------------#
@@ -30,6 +31,7 @@
 from pymodbus.mei_message import *
 from pymodbus.register_read_message import *
 from pymodbus.register_write_message import *
+from pymodbus.compat import IS_PYTHON3
 
 #--------------------------------------------------------------------------#
 # initialize logging
@@ -51,17 +53,17 @@
     WriteSingleRegisterRequest,
     WriteSingleCoilRequest,
     ReadWriteMultipleRegistersRequest,
-    
+
     ReadExceptionStatusRequest,
     GetCommEventCounterRequest,
     GetCommEventLogRequest,
     ReportSlaveIdRequest,
-    
+
     ReadFileRecordRequest,
     WriteFileRecordRequest,
     MaskWriteRegisterRequest,
     ReadFifoQueueRequest,
-    
+
     ReadDeviceInformationRequest,
 
     ReturnQueryDataRequest,
@@ -97,7 +99,7 @@
     WriteSingleRegisterResponse,
     WriteSingleCoilResponse,
     ReadWriteMultipleRegistersResponse,
-    
+
     ReadExceptionStatusResponse,
     GetCommEventCounterResponse,
     GetCommEventLogResponse,
@@ -149,13 +151,13 @@
     'write_registers'   : [0x01] * 8,
     'transaction'       : 0x01,
     'protocol'          : 0x00,
-    'unit'              : 0x01,
+    'unit'              : 0xff,
 }
 
 
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 # generate all the requested messages
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 def generate_messages(framer, options):
     ''' A helper method to parse the command line options
 
@@ -168,13 +170,16 @@ def generate_messages(framer, options):
         print ("%-44s = " % message.__class__.__name__)
         packet = framer.buildPacket(message)
         if not options.ascii:
-            packet = packet.encode('hex') + '\n'
-        print (packet)   # because ascii ends with a \r\n
+            if not IS_PYTHON3:
+                packet = packet.encode('hex')
+            else:
+                packet = c.encode(packet, 'hex_codec').decode('utf-8')
+        print ("{}\n".format(packet))   # because ascii ends with a \r\n
 
 
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 # initialize our program settings
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 def get_options():
     ''' A helper method to parse the command line options
 

examples/contrib/message-parser.py

@@ -11,20 +11,24 @@
 * rtu
 * binary
 '''
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 # import needed libraries
 #---------------------------------------------------------------------------#
 from __future__ import print_function
 import sys
 import collections
 import textwrap
 from optparse import OptionParser
+import codecs as c
+
 from pymodbus.utilities import computeCRC, computeLRC
 from pymodbus.factory import ClientDecoder, ServerDecoder
 from pymodbus.transaction import ModbusSocketFramer
 from pymodbus.transaction import ModbusBinaryFramer
 from pymodbus.transaction import ModbusAsciiFramer
 from pymodbus.transaction import ModbusRtuFramer
+from pymodbus.compat import byte2int, int2byte, IS_PYTHON3
+
 
 #--------------------------------------------------------------------------#
 # Logging
@@ -33,9 +37,9 @@
 modbus_log = logging.getLogger("pymodbus")
 
 
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 # build a quick wrapper around the framers
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 class Decoder(object):
 
     def __init__(self, framer, encode=False):
@@ -52,7 +56,10 @@ def decode(self, message):
 
         :param message: The messge to decode
         '''
-        value = message if self.encode else message.encode('hex')
+        if IS_PYTHON3:
+            value = message if self.encode else c.encode(message, 'hex_codec')
+        else:
+            value = message if self.encode else message.encode('hex')
         print("="*80)
         print("Decoding Message %s" % value)
         print("="*80)
@@ -64,7 +71,7 @@ def decode(self, message):
             print("%s" % decoder.decoder.__class__.__name__)
             print("-"*80)
             try:
-                decoder.addToFrame(message.encode())
+                decoder.addToFrame(message)
                 if decoder.checkFrame():
                     decoder.advanceFrame()
                     decoder.processIncomingPacket(message, self.report)
@@ -86,7 +93,7 @@ def report(self, message):
         :param message: The message to print
         '''
         print("%-15s = %s" % ('name', message.__class__.__name__))
-        for k,v in message.__dict__.iteritems():
+        for (k, v) in message.__dict__.items():
             if isinstance(v, dict):
                 print("%-15s =" % k)
                 for kk,vv in v.items():
@@ -102,9 +109,9 @@ def report(self, message):
         print("%-15s = %s" % ('documentation', message.__doc__))
 
 
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 # and decode our message
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
 def get_options():
     ''' A helper method to parse the command line options
 
@@ -136,6 +143,10 @@ def get_options():
         help="The file containing messages to parse",
         dest="file", default=None)
 
+    parser.add_option("-t", "--transaction",
+        help="If the incoming message is in hexadecimal format",
+        action="store_true", dest="transaction", default=False)
+
     (opt, arg) = parser.parse_args()
 
     if not opt.message and len(arg) > 0:
@@ -150,8 +161,19 @@ def get_messages(option):
     :returns: The message iterator to parse
     '''
     if option.message:
+        if option.transaction:
+            msg = ""
+            for segment in option.message.split():
+                segment = segment.replace("0x", "")
+                segment = "0" + segment if len(segment) == 1 else segment
+                msg = msg + segment
+            option.message = msg
+
         if not option.ascii:
-            option.message = option.message.decode('hex')
+            if not IS_PYTHON3:
+                option.message = option.message.decode('hex')
+            else:
+                option.message = c.decode(option.message.encode(), 'hex_codec')
         yield option.message
     elif option.file:
         with open(option.file, "r") as handle:

pymodbus/datastore/database/__init__.py

@@ -0,0 +1,7 @@
+from pymodbus.datastore.database.sql_datastore import SqlSlaveContext
+from pymodbus.datastore.database.redis_datastore import RedisSlaveContext
+
+#---------------------------------------------------------------------------#
+# Exported symbols
+#---------------------------------------------------------------------------#
+__all__ = ["SqlSlaveContext", "RedisSlaveContext"]