pymodbus 0.5__tar.gz

pymodbus-0.9.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 1.0
+Name: pymodbus
+Version: 0.9.0
+Summary: A fully featured modbus protocol stack in python
+Home-page: http://code.google.com/p/pymodbus/
+Author: Galen Collins
+Author-email: bashwork@gmail.com
+License: BSD
+Description: 
+        Pymodbus aims to be a fully implemented modbus protocol stack implemented
+        using twisted.  Its orignal goal was to allow simulation of thousands of
+        modbus devices on a single machine for monitoring software testing.
+        
+Keywords: modbus,twisted
+Platform: Linux
+Platform: Mac OS X
+Platform: Win
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: X11 Applications :: GTK
+Classifier: Framework :: Twisted
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities

pymodbus-0.9.0/pymodbus/__init__.py

@@ -0,0 +1,32 @@
+"""
+Pymodbus: Modbus Protocol Implementation
+-----------------------------------------
+
+TwistedModbus is built on top of the code developed by:
+
+    Copyright (c) 2001-2005 S.W.A.C. GmbH, Germany.
+    Copyright (c) 2001-2005 S.W.A.C. Bohemia s.r.o., Czech Republic.
+    Hynek Petrak <hynek@swac.cz>
+
+Released under the the BSD license
+"""
+
+from pymodbus.version import _version
+__version__ = _version.short()
+__author__  = 'Galen Collins'
+
+
+#---------------------------------------------------------------------------#
+# Block unhandled logging
+#---------------------------------------------------------------------------#
+import logging
+try:
+    from logging import NullHandler
+except ImportError:
+    class NullHandler(logging.Handler):
+        def emit(self, record):
+            pass
+
+h = NullHandler()
+logging.getLogger(__name__).addHandler(h)
+

pymodbus-0.9.0/pymodbus/bit_read_message.py

@@ -0,0 +1,228 @@
+"""
+Bit Reading Request/Response messages
+--------------------------------------
+
+"""
+import struct
+from pymodbus.pdu import ModbusRequest
+from pymodbus.pdu import ModbusResponse
+from pymodbus.pdu import ModbusExceptions as merror
+from pymodbus.utilities import pack_bitstring, unpack_bitstring
+
+class ReadBitsRequestBase(ModbusRequest):
+    ''' Base class for Messages Requesting bit values '''
+
+    _rtu_frame_size = 8
+
+    def __init__(self, address, count, **kwargs):
+        ''' Initializes the read request data
+
+        :param address: The start address to read from
+        :param count: The number of bits after 'address' to read
+        '''
+        ModbusRequest.__init__(self, **kwargs)
+        self.address = address
+        self.count   = count
+
+    def encode(self):
+        ''' Encodes a request pdu
+
+        :returns: The encoded pdu
+        '''
+        return struct.pack('>HH', self.address, self.count)
+
+    def decode(self, data):
+        ''' Decodes a request pdu
+
+        :param data: The packet data to decode
+        '''
+        self.address, self.count = struct.unpack('>HH', data)
+
+    def __str__(self):
+        ''' Returns a string representation of the instance
+
+        :returns: A string representation of the instance
+        '''
+        return "ReadBitRequest(%d,%d)" % (self.address, self.count)
+
+class ReadBitsResponseBase(ModbusResponse):
+    ''' Base class for Messages responding to bit-reading values '''
+
+    _rtu_byte_count_pos = 2
+
+    def __init__(self, values, **kwargs):
+        ''' Initializes a new instance
+
+        :param values: The requested values to be returned
+        '''
+        ModbusResponse.__init__(self, **kwargs)
+        self.bits = values or []
+
+    def encode(self):
+        ''' Encodes response pdu
+
+        :returns: The encoded packet message
+        '''
+        result = pack_bitstring(self.bits)
+        packet = struct.pack(">B", len(result)) + result
+        return packet
+
+    def decode(self, data):
+        ''' Decodes response pdu
+
+        :param data: The packet data to decode
+        '''
+        self.byte_count = struct.unpack(">B", data[0])[0]
+        self.bits = unpack_bitstring(data[1:])
+
+    def setBit(self, address, value=1):
+        ''' Helper function to set the specified bit
+
+        :param address: The bit to set
+        :param value: The value to set the bit to
+        '''
+        self.bits[address] = (value != 0)
+
+    def resetBit(self, address):
+        ''' Helper function to set the specified bit to 0
+
+        :param address: The bit to reset
+        '''
+        self.setBit(address, 0)
+
+    def getBit(self, address):
+        ''' Helper function to get the specified bit's value
+
+        :param address: The bit to query
+        :returns: The value of the requested bit
+        '''
+        return self.bits[address]
+
+    def __str__(self):
+        ''' Returns a string representation of the instance
+
+        :returns: A string representation of the instance
+        '''
+        return "ReadBitResponse(%d)" % len(self.bits)
+
+class ReadCoilsRequest(ReadBitsRequestBase):
+    '''
+    This function code is used to read from 1 to 2000(0x7d0) contiguous status
+    of coils in a remote device. The Request PDU specifies the starting
+    address, ie the address of the first coil specified, and the number of
+    coils. In the PDU Coils are addressed starting at zero. Therefore coils
+    numbered 1-16 are addressed as 0-15.
+    '''
+    function_code = 1
+
+    def __init__(self, address=None, count=None, **kwargs):
+        ''' Initializes a new instance
+
+        :param address: The address to start reading from
+        :param count: The number of bits to read
+        '''
+        ReadBitsRequestBase.__init__(self, address, count, **kwargs)
+
+    def execute(self, context):
+        ''' Run a read coils request against a datastore
+
+        Before running the request, we make sure that the request is in
+        the max valid range (0x001-0x7d0). Next we make sure that the
+        request is valid against the current datastore.
+
+        :param context: The datastore to request from
+        :returns: The initializes response message, exception message otherwise
+        '''
+        if not (1 <= self.count <= 0x7d0):
+            return self.doException(merror.IllegalValue)
+        if not context.validate(self.function_code, self.address, self.count):
+            return self.doException(merror.IllegalAddress)
+        values = context.getValues(self.function_code, self.address, self.count)
+        return ReadCoilsResponse(values)
+
+class ReadCoilsResponse(ReadBitsResponseBase):
+    '''
+    The coils in the response message are packed as one coil per bit of
+    the data field. Status is indicated as 1= ON and 0= OFF. The LSB of the
+    first data byte contains the output addressed in the query. The other
+    coils follow toward the high order end of this byte, and from low order
+    to high order in subsequent bytes.
+
+    If the returned output quantity is not a multiple of eight, the
+    remaining bits in the final data byte will be padded with zeros
+    (toward the high order end of the byte). The Byte Count field specifies
+    the quantity of complete bytes of data.
+    '''
+    function_code = 1
+
+    def __init__(self, values=None, **kwargs):
+        ''' Intializes a new instance
+
+        :param values: The request values to respond with
+        '''
+        ReadBitsResponseBase.__init__(self, values, **kwargs)
+
+class ReadDiscreteInputsRequest(ReadBitsRequestBase):
+    '''
+    This function code is used to read from 1 to 2000(0x7d0) contiguous status
+    of discrete inputs in a remote device. The Request PDU specifies the
+    starting address, ie the address of the first input specified, and the
+    number of inputs. In the PDU Discrete Inputs are addressed starting at
+    zero. Therefore Discrete inputs numbered 1-16 are addressed as 0-15.
+    '''
+    function_code = 2
+
+    def __init__(self, address=None, count=None, **kwargs):
+        ''' Intializes a new instance
+
+        :param address: The address to start reading from
+        :param count: The number of bits to read
+        '''
+        ReadBitsRequestBase.__init__(self, address, count, **kwargs)
+
+    def execute(self, context):
+        ''' Run a read discrete input request against a datastore
+
+        Before running the request, we make sure that the request is in
+        the max valid range (0x001-0x7d0). Next we make sure that the
+        request is valid against the current datastore.
+
+        :param context: The datastore to request from
+        :returns: The initializes response message, exception message otherwise
+        '''
+        if not (1 <= self.count <= 0x7d0):
+            return self.doException(merror.IllegalValue)
+        if not context.validate(self.function_code, self.address, self.count):
+            return self.doException(merror.IllegalAddress)
+        values = context.getValues(self.function_code, self.address, self.count)
+        return ReadDiscreteInputsResponse(values)
+
+class ReadDiscreteInputsResponse(ReadBitsResponseBase):
+    '''
+    The discrete inputs in the response message are packed as one input per
+    bit of the data field. Status is indicated as 1= ON; 0= OFF. The LSB of
+    the first data byte contains the input addressed in the query. The other
+    inputs follow toward the high order end of this byte, and from low order
+    to high order in subsequent bytes.
+
+    If the returned input quantity is not a multiple of eight, the
+    remaining bits in the final data byte will be padded with zeros
+    (toward the high order end of the byte). The Byte Count field specifies
+    the quantity of complete bytes of data.
+    '''
+    function_code = 2
+
+    def __init__(self, values=None, **kwargs):
+        ''' Intializes a new instance
+
+        :param values: The request values to respond with
+        '''
+        ReadBitsResponseBase.__init__(self, values, **kwargs)
+
+#---------------------------------------------------------------------------# 
+# Exported symbols
+#---------------------------------------------------------------------------# 
+__all__ = [
+    "ReadCoilsRequest", "ReadCoilsResponse",
+    "ReadDiscreteInputsRequest", "ReadDiscreteInputsResponse",
+]

pymodbus-0.9.0/pymodbus/bit_write_message.py

@@ -0,0 +1,251 @@
+"""
+Bit Writing Request/Response
+------------------------------
+
+TODO write mask request/response
+"""
+import struct
+from pymodbus.constants import ModbusStatus
+from pymodbus.pdu import ModbusRequest
+from pymodbus.pdu import ModbusResponse
+from pymodbus.pdu import ModbusExceptions as merror
+from pymodbus.exceptions import ParameterException
+from pymodbus.utilities import pack_bitstring, unpack_bitstring
+
+#---------------------------------------------------------------------------#
+# Local Constants
+#---------------------------------------------------------------------------#
+# These are defined in the spec to turn a coil on/off
+#---------------------------------------------------------------------------#
+_turn_coil_on  = struct.pack(">H", ModbusStatus.On)
+_turn_coil_off = struct.pack(">H", ModbusStatus.Off)
+
+class WriteSingleCoilRequest(ModbusRequest):
+    '''
+    This function code is used to write a single output to either ON or OFF
+    in a remote device.
+
+    The requested ON/OFF state is specified by a constant in the request
+    data field. A value of FF 00 hex requests the output to be ON. A value
+    of 00 00 requests it to be OFF. All other values are illegal and will
+    not affect the output.
+
+    The Request PDU specifies the address of the coil to be forced. Coils
+    are addressed starting at zero. Therefore coil numbered 1 is addressed
+    as 0. The requested ON/OFF state is specified by a constant in the Coil
+    Value field. A value of 0XFF00 requests the coil to be ON. A value of
+    0X0000 requests the coil to be off. All other values are illegal and
+    will not affect the coil.
+    '''
+    function_code = 5
+    _rtu_frame_size = 8
+
+    def __init__(self, address=None, value=None, **kwargs):
+        ''' Initializes a new instance
+
+        :param address: The variable address to write
+        :param value: The value to write at address
+        '''
+        ModbusRequest.__init__(self, **kwargs)
+        self.address = address
+        self.value = True if value else False
+
+    def encode(self):
+        ''' Encodes write coil request
+
+        :returns: The byte encoded message
+        '''
+        result  = struct.pack('>H', self.address)
+        result += _turn_coil_on if self.value else _turn_coil_off
+        return result
+
+    def decode(self, data):
+        ''' Decodes a write coil request
+
+        :param data: The packet data to decode
+        '''
+        self.address, value = struct.unpack('>HH', data)
+        self.value = True if value == ModbusStatus.On else False
+
+    def execute(self, context):
+        ''' Run a write coil request against a datastore
+
+        :param context: The datastore to request from
+        :returns: The populated response or exception message
+        '''
+        #if self.value not in [ModbusStatus.Off, ModbusStatus.On]:
+        #    return self.doException(merror.IllegalValue)
+        if not context.validate(self.function_code, self.address, 1):
+            return self.doException(merror.IllegalAddress)
+
+        context.setValues(self.function_code, self.address, self.value)
+        values = context.getValues(self.function_code, self.address, 1)
+        return WriteSingleCoilResponse(self.address, values[0])
+
+    def __str__(self):
+        ''' Returns a string representation of the instance
+
+        :return: A string representation of the instance
+        '''
+        return "WriteCoilRequest(%d, %s) => " % (self.address, self.value)
+
+class WriteSingleCoilResponse(ModbusResponse):
+    '''
+    The normal response is an echo of the request, returned after the coil
+    state has been written.
+    '''
+    function_code = 5
+    _rtu_frame_size = 8
+
+    def __init__(self, address=None, value=None, **kwargs):
+        ''' Initializes a new instance
+
+        :param address: The variable address written to
+        :param value: The value written at address
+        '''
+        ModbusResponse.__init__(self, **kwargs)
+        self.address = address
+        self.value = value
+
+    def encode(self):
+        ''' Encodes write coil response
+
+        :return: The byte encoded message
+        '''
+        result  = struct.pack('>H', self.address)
+        result += _turn_coil_on if self.value else _turn_coil_off
+        return result
+
+    def decode(self, data):
+        ''' Decodes a write coil response
+
+        :param data: The packet data to decode
+        '''
+        self.address, value = struct.unpack('>HH', data)
+        self.value = (value == ModbusStatus.On)
+
+    def __str__(self):
+        ''' Returns a string representation of the instance
+
+        :returns: A string representation of the instance
+        '''
+        return "WriteCoilResponse(%d) => %d" % (self.address, self.value)
+
+class WriteMultipleCoilsRequest(ModbusRequest):
+    '''
+    "This function code is used to force each coil in a sequence of coils to
+    either ON or OFF in a remote device. The Request PDU specifies the coil
+    references to be forced. Coils are addressed starting at zero. Therefore
+    coil numbered 1 is addressed as 0.
+
+    The requested ON/OFF states are specified by contents of the request
+    data field. A logical '1' in a bit position of the field requests the
+    corresponding output to be ON. A logical '0' requests it to be OFF."
+    '''
+    function_code = 15
+    _rtu_byte_count_pos = 6
+
+    def __init__(self, address=None, values=None, **kwargs):
+        ''' Initializes a new instance
+
+        :param address: The starting request address
+        :param values: The values to write
+        '''
+        ModbusRequest.__init__(self, **kwargs)
+        self.address = address
+        if not values: values = []
+        elif not hasattr(values, '__iter__'): values = [values]
+        self.values  = values
+        self.byte_count = (len(self.values) + 7) / 8
+
+    def encode(self):
+        ''' Encodes write coils request
+
+        :returns: The byte encoded message
+        '''
+        count   = len(self.values)
+        self.byte_count = (count + 7) / 8
+        packet  = struct.pack('>HHB', self.address, count, self.byte_count)
+        packet += pack_bitstring(self.values)
+        return packet
+
+    def decode(self, data):
+        ''' Decodes a write coils request
+
+        :param data: The packet data to decode
+        '''
+        self.address, count, self.byte_count = struct.unpack('>HHB', data[0:5])
+        values = unpack_bitstring(data[5:])
+        self.values = values[:count]
+
+    def execute(self, context):
+        ''' Run a write coils request against a datastore
+
+        :param context: The datastore to request from
+        :returns: The populated response or exception message
+        '''
+        count = len(self.values)
+        if not (1 <= count <= 0x07b0):
+            return self.doException(merror.IllegalValue)
+        if (self.byte_count != (count + 7) / 8):
+            return self.doException(merror.IllegalValue)
+        if not context.validate(self.function_code, self.address, count):
+            return self.doException(merror.IllegalAddress)
+
+        context.setValues(self.function_code, self.address, self.values)
+        return WriteMultipleCoilsResponse(self.address, count)
+
+    def __str__(self):
+        ''' Returns a string representation of the instance
+
+        :returns: A string representation of the instance
+        '''
+        params = (self.address, len(self.values))
+        return "WriteNCoilRequest (%d) => %d " % params
+
+class WriteMultipleCoilsResponse(ModbusResponse):
+    '''
+    The normal response returns the function code, starting address, and
+    quantity of coils forced.
+    '''
+    function_code = 15
+    _rtu_frame_size = 8
+
+    def __init__(self, address=None, count=None, **kwargs):
+        ''' Initializes a new instance
+
+        :param address: The starting variable address written to
+        :param count: The number of values written
+        '''
+        ModbusResponse.__init__(self, **kwargs)
+        self.address = address
+        self.count = count
+
+    def encode(self):
+        ''' Encodes write coils response
+
+        :returns: The byte encoded message
+        '''
+        return struct.pack('>HH', self.address, self.count)
+
+    def decode(self, data):
+        ''' Decodes a write coils response
+
+        :param data: The packet data to decode
+        '''
+        self.address, self.count = struct.unpack('>HH', data)
+
+    def __str__(self):
+        ''' Returns a string representation of the instance
+
+        :returns: A string representation of the instance
+        '''
+        return "WriteNCoilResponse(%d, %d)" % (self.address, self.count)
+
+#---------------------------------------------------------------------------# 
+# Exported symbols
+#---------------------------------------------------------------------------# 
+__all__ = [
+    "WriteSingleCoilRequest", "WriteSingleCoilResponse",
+    "WriteMultipleCoilsRequest", "WriteMultipleCoilsResponse",
+]

pymodbus-0.9.0/pymodbus/client/async.py

@@ -0,0 +1,140 @@
+"""
+Implementation of a Modbus Client Using Twisted
+--------------------------------------------------
+
+Example Run::
+
+    from pymodbus.client.async import ModbusClientFactory
+    from pymodbus.bit_read_message import ReadCoilsRequest
+
+    def clientTest():
+        requests = [ ReadCoilsRequest(0,99) ]
+        p = reactor.connectTCP("localhost", 502, ModbusClientFactory(requests))
+    
+    if __name__ == "__main__":
+       reactor.callLater(1, clientTest)
+       reactor.run()
+"""
+import struct
+from collections import deque
+
+from twisted.internet import reactor, defer, protocol
+
+from pymodbus.factory import ClientDecoder
+from pymodbus.exceptions import ConnectionException
+from pymodbus.transaction import ModbusSocketFramer
+from pymodbus.client.common import ModbusClientMixin
+
+#---------------------------------------------------------------------------#
+# Logging
+#---------------------------------------------------------------------------#
+import logging
+_logger = logging.getLogger(__name__)
+
+#---------------------------------------------------------------------------#
+# Client Protocols
+#---------------------------------------------------------------------------#
+class ModbusClientProtocol(protocol.Protocol, ModbusClientMixin):
+    '''
+    This represents the base modbus client protocol.  All the application
+    layer code is deferred to a higher level wrapper.
+    '''
+    __tid = 0
+
+    def __init__(self, framer=None):
+        ''' Initializes the framer module
+
+        :param framer: The framer to use for the protocol
+        '''
+        self.framer = framer or ModbusSocketFramer(ClientDecoder())
+        self._requests = deque() # link queue to tid
+        self._connected = False
+
+    def connectionMade(self):
+        ''' Called upon a successful client connection.
+        '''
+        _logger.debug("Client connected to modbus server")
+        self._connected = True
+
+    def connectionLost(self, reason):
+        ''' Called upon a client disconnect
+
+        :param reason: The reason for the disconnect
+        '''
+        _logger.debug("Client disconnected from modbus server: %s" % reason)
+        self._connected = False
+
+    def dataReceived(self, data):
+        ''' Get response, check for valid message, decode result
+
+        :param data: The data returned from the server
+        '''
+        self.framer.processIncomingPacket(data, self._callback)
+
+    def execute(self, request):
+        ''' Starts the producer to send the next request to
+        consumer.write(Frame(request))
+        '''
+        request.transaction_id = self.__getNextTID()
+        #self.handler[request.transaction_id] = request
+        packet = self.framer.buildPacket(request)
+        self.transport.write(packet)
+        return self._buildResponse()
+
+    def _callback(self, reply):
+        ''' The callback to call with the response message
+
+        :param reply: The decoded response message
+        '''
+        # todo errback/callback
+        if self._requests:
+            self._requests.popleft().callback(reply)
+
+    def _buildResponse(self):
+        ''' Helper method to return a deferred response
+        for the current request.
+
+        :returns: A defer linked to the latest request
+        '''
+        if not self._connected:
+            return defer.fail(ConnectionException('Client is not connected'))
+
+        d = defer.Deferred()
+        self._requests.append(d)
+        return d
+
+    def __getNextTID(self):
+        ''' Used to retrieve the next transaction id
+        :return: The next unique transaction id
+
+        As the transaction identifier is represented with two
+        bytes, the highest TID is 0xffff
+
+        ..todo:: Remove this and use the transaction manager
+        '''
+        tid = (ModbusClientProtocol.__tid + 1) & 0xffff
+        ModbusClientProtocol.__tid = tid
+        return tid
+
+    #----------------------------------------------------------------------#
+    # Extra Functions
+    #----------------------------------------------------------------------#
+    #if send_failed:
+    #       if self.retry > 0:
+    #               deferLater(clock, self.delay, send, message)
+    #               self.retry -= 1
+
+#---------------------------------------------------------------------------#
+# Client Factories
+#---------------------------------------------------------------------------#
+class ModbusClientFactory(protocol.ReconnectingClientFactory):
+    ''' Simple client protocol factory '''
+
+    protocol = ModbusClientProtocol
+
+#---------------------------------------------------------------------------# 
+# Exported symbols
+#---------------------------------------------------------------------------# 
+__all__ = [
+    "ModbusClientProtocol", "ModbusClientFactory",
+]