'''
if self.pre:
return '%d.%d.%d.%s' % (self.major, self.minor, self.micro, self.pre)
else:
return '%d.%d.%d' % (self.major, self.minor, self.micro)
def __str__(self):
''' Returns a string representation of the object
:returns: A string representation of this object
'''
return '[%s, version %s]' % (self.package, self.short())
version = Version('pymodbus', 1, 3, 2)
version.__name__ = 'pymodbus' # fix epydoc error
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = ["version"]
pymodbus-1.3.2/pymodbus/interfaces.py 0000644 0001750 0001750 00000017504 13150360615 016061 0 ustar wmb wmb '''
Pymodbus Interfaces
---------------------
A collection of base classes that are used throughout
the pymodbus library.
'''
from pymodbus.exceptions import NotImplementedException
#---------------------------------------------------------------------------#
# Generic
#---------------------------------------------------------------------------#
class Singleton(object):
'''
Singleton base class
http://mail.python.org/pipermail/python-list/2007-July/450681.html
'''
def __new__(cls, *args, **kwargs):
''' Create a new instance
'''
if '_inst' not in vars(cls):
cls._inst = object.__new__(cls)
return cls._inst
#---------------------------------------------------------------------------#
# Project Specific
#---------------------------------------------------------------------------#
class IModbusDecoder(object):
''' Modbus Decoder Base Class
This interface must be implemented by a modbus message
decoder factory. These factories are responsible for
abstracting away converting a raw packet into a request / response
message object.
'''
def decode(self, message):
''' Wrapper to decode a given packet
:param message: The raw modbus request packet
:return: The decoded modbus message or None if error
'''
raise NotImplementedException(
"Method not implemented by derived class")
def lookupPduClass(self, function_code):
''' Use `function_code` to determine the class of the PDU.
:param function_code: The function code specified in a frame.
:returns: The class of the PDU that has a matching `function_code`.
'''
raise NotImplementedException(
"Method not implemented by derived class")
class IModbusFramer(object):
'''
A framer strategy interface. The idea is that we abstract away all the
detail about how to detect if a current message frame exists, decoding
it, sending it, etc so that we can plug in a new Framer object (tcp,
rtu, ascii).
'''
def checkFrame(self):
''' Check and decode the next frame
:returns: True if we successful, False otherwise
'''
raise NotImplementedException(
"Method not implemented by derived class")
def advanceFrame(self):
''' Skip over the current framed message
This allows us to skip over the current message after we have processed
it or determined that it contains an error. It also has to reset the
current frame header handle
'''
raise NotImplementedException(
"Method not implemented by derived class")
def addToFrame(self, message):
''' Add the next message to the frame buffer
This should be used before the decoding while loop to add the received
data to the buffer handle.
:param message: The most recent packet
'''
raise NotImplementedException(
"Method not implemented by derived class")
def isFrameReady(self):
''' Check if we should continue decode logic
This is meant to be used in a while loop in the decoding phase to let
the decoder know that there is still data in the buffer.
:returns: True if ready, False otherwise
'''
raise NotImplementedException(
"Method not implemented by derived class")
def getFrame(self):
''' Get the next frame from the buffer
:returns: The frame data or ''
'''
raise NotImplementedException(
"Method not implemented by derived class")
def populateResult(self, result):
''' Populates the modbus result with current frame header
We basically copy the data back over from the current header
to the result header. This may not be needed for serial messages.
:param result: The response packet
'''
raise NotImplementedException(
"Method not implemented by derived class")
def processIncomingPacket(self, data, callback):
''' The new packet processing pattern
This takes in a new request packet, adds it to the current
packet stream, and performs framing on it. That is, checks
for complete messages, and once found, will process all that
exist. This handles the case when we read N + 1 or 1 / N
messages at a time instead of 1.
The processed and decoded messages are pushed to the callback
function to process and send.
:param data: The new packet data
:param callback: The function to send results to
'''
raise NotImplementedException(
"Method not implemented by derived class")
def buildPacket(self, message):
''' Creates a ready to send modbus packet
The raw packet is built off of a fully populated modbus
request / response message.
:param message: The request/response to send
:returns: The built packet
'''
raise NotImplementedException(
"Method not implemented by derived class")
class IModbusSlaveContext(object):
'''
Interface for a modbus slave data context
Derived classes must implemented the following methods:
reset(self)
validate(self, fx, address, count=1)
getValues(self, fx, address, count=1)
setValues(self, fx, address, values)
'''
__fx_mapper = {2: 'd', 4: 'i'}
__fx_mapper.update([(i, 'h') for i in [3, 6, 16, 22, 23]])
__fx_mapper.update([(i, 'c') for i in [1, 5, 15]])
def decode(self, fx):
''' Converts the function code to the datastore to
:param fx: The function we are working with
:returns: one of [d(iscretes),i(inputs),h(oliding),c(oils)
'''
return self.__fx_mapper[fx]
def reset(self):
''' Resets all the datastores to their default values
'''
raise NotImplementedException("Context Reset")
def validate(self, fx, address, count=1):
''' Validates the request to make sure it is in range
:param fx: The function we are working with
:param address: The starting address
:param count: The number of values to test
:returns: True if the request in within range, False otherwise
'''
raise NotImplementedException("validate context values")
def getValues(self, fx, address, count=1):
''' Validates the request to make sure it is in range
:param fx: The function we are working with
:param address: The starting address
:param count: The number of values to retrieve
:returns: The requested values from a:a+c
'''
raise NotImplementedException("get context values")
def setValues(self, fx, address, values):
''' Sets the datastore with the supplied values
:param fx: The function we are working with
:param address: The starting address
:param values: The new values to be set
'''
raise NotImplementedException("set context values")
class IPayloadBuilder(object):
'''
This is an interface to a class that can build a payload
for a modbus register write command. It should abstract
the codec for encoding data to the required format
(bcd, binary, char, etc).
'''
def build(self):
''' Return the payload buffer as a list
This list is two bytes per element and can
thus be treated as a list of registers.
:returns: The payload buffer as a list
'''
raise NotImplementedException("set context values")
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
'Singleton',
'IModbusDecoder', 'IModbusFramer', 'IModbusSlaveContext',
'IPayloadBuilder',
]
pymodbus-1.3.2/pymodbus/device.py 0000644 0001750 0001750 00000054742 13150360615 015202 0 ustar wmb wmb """
Modbus Device Controller
-------------------------
These are the device management handlers. They should be
maintained in the server context and the various methods
should be inserted in the correct locations.
"""
from pymodbus.constants import DeviceInformation
from pymodbus.interfaces import Singleton
from pymodbus.utilities import dict_property
from pymodbus.compat import iteritems, itervalues, izip, int2byte
from collections import OrderedDict
#---------------------------------------------------------------------------#
# Network Access Control
#---------------------------------------------------------------------------#
class ModbusAccessControl(Singleton):
'''
This is a simple implementation of a Network Management System table.
Its purpose is to control access to the server (if it is used).
We assume that if an entry is in the table, it is allowed accesses to
resources. However, if the host does not appear in the table (all
unknown hosts) its connection will simply be closed.
Since it is a singleton, only one version can possible exist and all
instances pull from here.
'''
__nmstable = [
"127.0.0.1",
]
def __iter__(self):
''' Iterater over the network access table
:returns: An iterator of the network access table
'''
return self.__nmstable.__iter__()
def __contains__(self, host):
''' Check if a host is allowed to access resources
:param host: The host to check
'''
return host in self.__nmstable
def add(self, host):
''' Add allowed host(s) from the NMS table
:param host: The host to add
'''
if not isinstance(host, list):
host = [host]
for entry in host:
if entry not in self.__nmstable:
self.__nmstable.append(entry)
def remove(self, host):
''' Remove allowed host(s) from the NMS table
:param host: The host to remove
'''
if not isinstance(host, list):
host = [host]
for entry in host:
if entry in self.__nmstable:
self.__nmstable.remove(entry)
def check(self, host):
''' Check if a host is allowed to access resources
:param host: The host to check
'''
return host in self.__nmstable
#---------------------------------------------------------------------------#
# Modbus Plus Statistics
#---------------------------------------------------------------------------#
class ModbusPlusStatistics(object):
'''
This is used to maintain the current modbus plus statistics count. As of
right now this is simply a stub to complete the modbus implementation.
For more information, see the modbus implementation guide page 87.
'''
__data = OrderedDict({
'node_type_id' : [0x00] * 2, # 00
'software_version_number' : [0x00] * 2, # 01
'network_address' : [0x00] * 2, # 02
'mac_state_variable' : [0x00] * 2, # 03
'peer_status_code' : [0x00] * 2, # 04
'token_pass_counter' : [0x00] * 2, # 05
'token_rotation_time' : [0x00] * 2, # 06
'program_master_token_failed' : [0x00], # 07 hi
'data_master_token_failed' : [0x00], # 07 lo
'program_master_token_owner' : [0x00], # 08 hi
'data_master_token_owner' : [0x00], # 08 lo
'program_slave_token_owner' : [0x00], # 09 hi
'data_slave_token_owner' : [0x00], # 09 lo
'data_slave_command_transfer' : [0x00], # 10 hi
'__unused_10_lowbit' : [0x00], # 10 lo
'program_slave_command_transfer' : [0x00], # 11 hi
'program_master_rsp_transfer' : [0x00], # 11 lo
'program_slave_auto_logout' : [0x00], # 12 hi
'program_master_connect_status' : [0x00], # 12 lo
'receive_buffer_dma_overrun' : [0x00], # 13 hi
'pretransmit_deferral_error' : [0x00], # 13 lo
'frame_size_error' : [0x00], # 14 hi
'repeated_command_received' : [0x00], # 14 lo
'receiver_alignment_error' : [0x00], # 15 hi
'receiver_collision_abort_error' : [0x00], # 15 lo
'bad_packet_length_error' : [0x00], # 16 hi
'receiver_crc_error' : [0x00], # 16 lo
'transmit_buffer_dma_underrun' : [0x00], # 17 hi
'bad_link_address_error' : [0x00], # 17 lo
'bad_mac_function_code_error' : [0x00], # 18 hi
'internal_packet_length_error' : [0x00], # 18 lo
'communication_failed_error' : [0x00], # 19 hi
'communication_retries' : [0x00], # 19 lo
'no_response_error' : [0x00], # 20 hi
'good_receive_packet' : [0x00], # 20 lo
'unexpected_path_error' : [0x00], # 21 hi
'exception_response_error' : [0x00], # 21 lo
'forgotten_transaction_error' : [0x00], # 22 hi
'unexpected_response_error' : [0x00], # 22 lo
'active_station_bit_map' : [0x00] * 8, # 23-26
'token_station_bit_map' : [0x00] * 8, # 27-30
'global_data_bit_map' : [0x00] * 8, # 31-34
'receive_buffer_use_bit_map' : [0x00] * 8, # 35-37
'data_master_output_path' : [0x00] * 8, # 38-41
'data_slave_input_path' : [0x00] * 8, # 42-45
'program_master_outptu_path' : [0x00] * 8, # 46-49
'program_slave_input_path' : [0x00] * 8, # 50-53
})
def __init__(self):
'''
Initialize the modbus plus statistics with the default
information.
'''
self.reset()
def __iter__(self):
''' Iterater over the statistics
:returns: An iterator of the modbus plus statistics
'''
return iteritems(self.__data)
def reset(self):
''' This clears all of the modbus plus statistics
'''
for key in self.__data:
self.__data[key] = [0x00] * len(self.__data[key])
def summary(self):
''' Returns a summary of the modbus plus statistics
:returns: 54 16-bit words representing the status
'''
return itervalues(self.__data)
def encode(self):
''' Returns a summary of the modbus plus statistics
:returns: 54 16-bit words representing the status
'''
total, values = [], sum(self.__data.values(), [])
for c in range(0, len(values), 2):
total.append((values[c] << 8) | values[c+1])
return total
#---------------------------------------------------------------------------#
# Device Information Control
#---------------------------------------------------------------------------#
class ModbusDeviceIdentification(object):
'''
This is used to supply the device identification
for the readDeviceIdentification function
For more information read section 6.21 of the modbus
application protocol.
'''
__data = {
0x00: '', # VendorName
0x01: '', # ProductCode
0x02: '', # MajorMinorRevision
0x03: '', # VendorUrl
0x04: '', # ProductName
0x05: '', # ModelName
0x06: '', # UserApplicationName
0x07: '', # reserved
0x08: '', # reserved
# 0x80 -> 0xFF are private
}
__names = [
'VendorName',
'ProductCode',
'MajorMinorRevision',
'VendorUrl',
'ProductName',
'ModelName',
'UserApplicationName',
]
def __init__(self, info=None):
'''
Initialize the datastore with the elements you need.
(note acceptable range is [0x00-0x06,0x80-0xFF] inclusive)
:param information: A dictionary of {int:string} of values
'''
if isinstance(info, dict):
for key in info:
if (0x06 >= key >= 0x00) or (0x80 > key > 0x08):
self.__data[key] = info[key]
def __iter__(self):
''' Iterater over the device information
:returns: An iterator of the device information
'''
return iteritems(self.__data)
def summary(self):
''' Return a summary of the main items
:returns: An dictionary of the main items
'''
return dict(zip(self.__names, itervalues(self.__data)))
def update(self, value):
''' Update the values of this identity
using another identify as the value
:param value: The value to copy values from
'''
self.__data.update(value)
def __setitem__(self, key, value):
''' Wrapper used to access the device information
:param key: The register to set
:param value: The new value for referenced register
'''
if key not in [0x07, 0x08]:
self.__data[key] = value
def __getitem__(self, key):
''' Wrapper used to access the device information
:param key: The register to read
'''
return self.__data.setdefault(key, '')
def __str__(self):
''' Build a representation of the device
:returns: A string representation of the device
'''
return "DeviceIdentity"
#-------------------------------------------------------------------------#
# Properties
#-------------------------------------------------------------------------#
VendorName = dict_property(lambda s: s.__data, 0)
ProductCode = dict_property(lambda s: s.__data, 1)
MajorMinorRevision = dict_property(lambda s: s.__data, 2)
VendorUrl = dict_property(lambda s: s.__data, 3)
ProductName = dict_property(lambda s: s.__data, 4)
ModelName = dict_property(lambda s: s.__data, 5)
UserApplicationName = dict_property(lambda s: s.__data, 6)
class DeviceInformationFactory(Singleton):
''' This is a helper factory that really just hides
some of the complexity of processing the device information
requests (function code 0x2b 0x0e).
'''
__lookup = {
DeviceInformation.Basic: lambda c,r,i: c.__gets(r, list(range(0x00, 0x03))),
DeviceInformation.Regular: lambda c,r,i: c.__gets(r, list(range(0x00, 0x08))),
DeviceInformation.Extended: lambda c,r,i: c.__gets(r, list(range(0x80, i))),
DeviceInformation.Specific: lambda c,r,i: c.__get(r, i),
}
@classmethod
def get(cls, control, read_code=DeviceInformation.Basic, object_id=0x00):
''' Get the requested device data from the system
:param control: The control block to pull data from
:param read_code: The read code to process
:param object_id: The specific object_id to read
:returns: The requested data (id, length, value)
'''
identity = control.Identity
return cls.__lookup[read_code](cls, identity, object_id)
@classmethod
def __get(cls, identity, object_id):
''' Read a single object_id from the device information
:param identity: The identity block to pull data from
:param object_id: The specific object id to read
:returns: The requested data (id, length, value)
'''
return { object_id:identity[object_id] }
@classmethod
def __gets(cls, identity, object_ids):
''' Read multiple object_ids from the device information
:param identity: The identity block to pull data from
:param object_ids: The specific object ids to read
:returns: The requested data (id, length, value)
'''
return dict((oid, identity[oid]) for oid in object_ids)
#---------------------------------------------------------------------------#
# Counters Handler
#---------------------------------------------------------------------------#
class ModbusCountersHandler(object):
'''
This is a helper class to simplify the properties for the counters::
0x0B 1 Return Bus Message Count
Quantity of messages that the remote
device has detected on the communications system since its
last restart, clear counters operation, or power-up. Messages
with bad CRC are not taken into account.
0x0C 2 Return Bus Communication Error Count
Quantity of CRC errors encountered by the remote device since its
last restart, clear counters operation, or power-up. In case of
an error detected on the character level, (overrun, parity error),
or in case of a message length < 3 bytes, the receiving device is
not able to calculate the CRC. In such cases, this counter is
also incremented.
0x0D 3 Return Slave Exception Error Count
Quantity of MODBUS exception error detected by the remote device
since its last restart, clear counters operation, or power-up. It
comprises also the error detected in broadcast messages even if an
exception message is not returned in this case.
Exception errors are described and listed in "MODBUS Application
Protocol Specification" document.
0xOE 4 Return Slave Message Count
Quantity of messages addressed to the remote device, including
broadcast messages, that the remote device has processed since its
last restart, clear counters operation, or power-up.
0x0F 5 Return Slave No Response Count
Quantity of messages received by the remote device for which it
returned no response (neither a normal response nor an exception
response), since its last restart, clear counters operation, or
power-up. Then, this counter counts the number of broadcast
messages it has received.
0x10 6 Return Slave NAK Count
Quantity of messages addressed to the remote device for which it
returned a Negative Acknowledge (NAK) exception response, since
its last restart, clear counters operation, or power-up. Exception
responses are described and listed in "MODBUS Application Protocol
Specification" document.
0x11 7 Return Slave Busy Count
Quantity of messages addressed to the remote device for which it
returned a Slave Device Busy exception response, since its last
restart, clear counters operation, or power-up. Exception
responses are described and listed in "MODBUS Application
Protocol Specification" document.
0x12 8 Return Bus Character Overrun Count
Quantity of messages addressed to the remote device that it could
not handle due to a character overrun condition, since its last
restart, clear counters operation, or power-up. A character
overrun is caused by data characters arriving at the port faster
than they can.
.. note:: I threw the event counter in here for convinience
'''
__data = dict([(i, 0x0000) for i in range(9)])
__names = [
'BusMessage',
'BusCommunicationError',
'SlaveExceptionError',
'SlaveMessage',
'SlaveNoResponse',
'SlaveNAK',
'SlaveBusy',
'BusCharacterOverrun'
'Event '
]
def __iter__(self):
''' Iterater over the device counters
:returns: An iterator of the device counters
'''
return izip(self.__names, itervalues(self.__data))
def update(self, values):
''' Update the values of this identity
using another identify as the value
:param values: The value to copy values from
'''
for k, v in iteritems(values):
v += self.__getattribute__(k)
self.__setattr__(k, v)
def reset(self):
''' This clears all of the system counters
'''
self.__data = dict([(i, 0x0000) for i in range(9)])
def summary(self):
''' Returns a summary of the counters current status
:returns: A byte with each bit representing each counter
'''
count, result = 0x01, 0x00
for i in itervalues(self.__data):
if i != 0x00: result |= count
count <<= 1
return result
#-------------------------------------------------------------------------#
# Properties
#-------------------------------------------------------------------------#
BusMessage = dict_property(lambda s: s.__data, 0)
BusCommunicationError = dict_property(lambda s: s.__data, 1)
BusExceptionError = dict_property(lambda s: s.__data, 2)
SlaveMessage = dict_property(lambda s: s.__data, 3)
SlaveNoResponse = dict_property(lambda s: s.__data, 4)
SlaveNAK = dict_property(lambda s: s.__data, 5)
SlaveBusy = dict_property(lambda s: s.__data, 6)
BusCharacterOverrun = dict_property(lambda s: s.__data, 7)
Event = dict_property(lambda s: s.__data, 8)
#---------------------------------------------------------------------------#
# Main server control block
#---------------------------------------------------------------------------#
class ModbusControlBlock(Singleton):
'''
This is a global singleotn that controls all system information
All activity should be logged here and all diagnostic requests
should come from here.
'''
__mode = 'ASCII'
__diagnostic = [False] * 16
__instance = None
__listen_only = False
__delimiter = '\r'
__counters = ModbusCountersHandler()
__identity = ModbusDeviceIdentification()
__plus = ModbusPlusStatistics()
__events = []
#-------------------------------------------------------------------------#
# Magic
#-------------------------------------------------------------------------#
def __str__(self):
''' Build a representation of the control block
:returns: A string representation of the control block
'''
return "ModbusControl"
def __iter__(self):
''' Iterater over the device counters
:returns: An iterator of the device counters
'''
return self.__counters.__iter__()
#-------------------------------------------------------------------------#
# Events
#-------------------------------------------------------------------------#
def addEvent(self, event):
''' Adds a new event to the event log
:param event: A new event to add to the log
'''
self.__events.insert(0, event)
self.__events = self.__events[0:64] # chomp to 64 entries
self.Counter.Event += 1
def getEvents(self):
''' Returns an encoded collection of the event log.
:returns: The encoded events packet
'''
events = [event.encode() for event in self.__events]
return b''.join(events)
def clearEvents(self):
''' Clears the current list of events
'''
self.__events = []
#-------------------------------------------------------------------------#
# Other Properties
#-------------------------------------------------------------------------#
Identity = property(lambda s: s.__identity)
Counter = property(lambda s: s.__counters)
Events = property(lambda s: s.__events)
Plus = property(lambda s: s.__plus)
def reset(self):
''' This clears all of the system counters and the
diagnostic register
'''
self.__events = []
self.__counters.reset()
self.__diagnostic = [False] * 16
#-------------------------------------------------------------------------#
# Listen Properties
#-------------------------------------------------------------------------#
def _setListenOnly(self, value):
''' This toggles the listen only status
:param value: The value to set the listen status to
'''
self.__listen_only = bool(value)
ListenOnly = property(lambda s: s.__listen_only, _setListenOnly)
#-------------------------------------------------------------------------#
# Mode Properties
#-------------------------------------------------------------------------#
def _setMode(self, mode):
''' This toggles the current serial mode
:param mode: The data transfer method in (RTU, ASCII)
'''
if mode in ['ASCII', 'RTU']:
self.__mode = mode
Mode = property(lambda s: s.__mode, _setMode)
#-------------------------------------------------------------------------#
# Delimiter Properties
#-------------------------------------------------------------------------#
def _setDelimiter(self, char):
''' This changes the serial delimiter character
:param char: The new serial delimiter character
'''
if isinstance(char, str):
self.__delimiter = char.encode()
if isinstance(char, bytes):
self.__delimiter = char
elif isinstance(char, int):
self.__delimiter = int2byte(char)
Delimiter = property(lambda s: s.__delimiter, _setDelimiter)
#-------------------------------------------------------------------------#
# Diagnostic Properties
#-------------------------------------------------------------------------#
def setDiagnostic(self, mapping):
''' This sets the value in the diagnostic register
:param mapping: Dictionary of key:value pairs to set
'''
for entry in iteritems(mapping):
if entry[0] >= 0 and entry[0] < len(self.__diagnostic):
self.__diagnostic[entry[0]] = (entry[1] != 0)
def getDiagnostic(self, bit):
''' This gets the value in the diagnostic register
:param bit: The bit to get
:returns: The current value of the requested bit
'''
try:
if bit and bit >= 0 and bit < len(self.__diagnostic):
return self.__diagnostic[bit]
except Exception:
return None
def getDiagnosticRegister(self):
''' This gets the entire diagnostic register
:returns: The diagnostic register collection
'''
return self.__diagnostic
#---------------------------------------------------------------------------#
# Exported Identifiers
#---------------------------------------------------------------------------#
__all__ = [
"ModbusAccessControl",
"ModbusPlusStatistics",
"ModbusDeviceIdentification",
"DeviceInformationFactory",
"ModbusControlBlock"
]
pymodbus-1.3.2/pymodbus/datastore/ 0000755 0001750 0001750 00000000000 13150360615 015343 5 ustar wmb wmb pymodbus-1.3.2/pymodbus/datastore/__init__.py 0000644 0001750 0001750 00000001030 13150360615 017446 0 ustar wmb wmb from pymodbus.datastore.store import ModbusSequentialDataBlock
from pymodbus.datastore.store import ModbusSparseDataBlock
from pymodbus.datastore.context import ModbusSlaveContext
from pymodbus.datastore.context import ModbusServerContext
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"ModbusSequentialDataBlock", "ModbusSparseDataBlock",
"ModbusSlaveContext", "ModbusServerContext",
]
pymodbus-1.3.2/pymodbus/datastore/store.py 0000644 0001750 0001750 00000021134 13150360615 017052 0 ustar wmb wmb """
Modbus Server Datastore
-------------------------
For each server, you will create a ModbusServerContext and pass
in the default address space for each data access. The class
will create and manage the data.
Further modification of said data accesses should be performed
with [get,set][access]Values(address, count)
Datastore Implementation
-------------------------
There are two ways that the server datastore can be implemented.
The first is a complete range from 'address' start to 'count'
number of indecies. This can be thought of as a straight array::
data = range(1, 1 + count)
[1,2,3,...,count]
The other way that the datastore can be implemented (and how
many devices implement it) is a associate-array::
data = {1:'1', 3:'3', ..., count:'count'}
[1,3,...,count]
The difference between the two is that the latter will allow
arbitrary gaps in its datastore while the former will not.
This is seen quite commonly in some modbus implementations.
What follows is a clear example from the field:
Say a company makes two devices to monitor power usage on a rack.
One works with three-phase and the other with a single phase. The
company will dictate a modbus data mapping such that registers::
n: phase 1 power
n+1: phase 2 power
n+2: phase 3 power
Using this, layout, the first device will implement n, n+1, and n+2,
however, the second device may set the latter two values to 0 or
will simply not implmented the registers thus causing a single read
or a range read to fail.
I have both methods implemented, and leave it up to the user to change
based on their preference.
"""
from pymodbus.exceptions import NotImplementedException, ParameterException
from pymodbus.compat import iteritems, iterkeys, itervalues, get_next
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Datablock Storage
#---------------------------------------------------------------------------#
class BaseModbusDataBlock(object):
'''
Base class for a modbus datastore
Derived classes must create the following fields:
@address The starting address point
@defult_value The default value of the datastore
@values The actual datastore values
Derived classes must implemented the following methods:
validate(self, address, count=1)
getValues(self, address, count=1)
setValues(self, address, values)
'''
def default(self, count, value=False):
''' Used to initialize a store to one value
:param count: The number of fields to set
:param value: The default value to set to the fields
'''
self.default_value = value
self.values = [self.default_value] * count
self.address = 0x00
def reset(self):
''' Resets the datastore to the initialized default value '''
self.values = [self.default_value] * len(self.values)
def validate(self, address, count=1):
''' Checks to see if the request is in range
:param address: The starting address
:param count: The number of values to test for
:returns: True if the request in within range, False otherwise
'''
raise NotImplementedException("Datastore Address Check")
def getValues(self, address, count=1):
''' Returns the requested values from the datastore
:param address: The starting address
:param count: The number of values to retrieve
:returns: The requested values from a:a+c
'''
raise NotImplementedException("Datastore Value Retrieve")
def setValues(self, address, values):
''' Returns the requested values from the datastore
:param address: The starting address
:param values: The values to store
'''
raise NotImplementedException("Datastore Value Retrieve")
def __str__(self):
''' Build a representation of the datastore
:returns: A string representation of the datastore
'''
return "DataStore(%d, %d)" % (len(self.values), self.default_value)
def __iter__(self):
''' Iterater over the data block data
:returns: An iterator of the data block data
'''
if isinstance(self.values, dict):
return iteritems(self.values)
return enumerate(self.values, self.address)
class ModbusSequentialDataBlock(BaseModbusDataBlock):
''' Creates a sequential modbus datastore '''
def __init__(self, address, values):
''' Initializes the datastore
:param address: The starting address of the datastore
:param values: Either a list or a dictionary of values
'''
self.address = address
if hasattr(values, '__iter__'):
self.values = list(values)
else: self.values = [values]
self.default_value = self.values[0].__class__()
@classmethod
def create(klass):
''' Factory method to create a datastore with the
full address space initialized to 0x00
:returns: An initialized datastore
'''
return klass(0x00, [0x00] * 65536)
def validate(self, address, count=1):
''' Checks to see if the request is in range
:param address: The starting address
:param count: The number of values to test for
:returns: True if the request in within range, False otherwise
'''
result = (self.address <= address)
result &= ((self.address + len(self.values)) >= (address + count))
return result
def getValues(self, address, count=1):
''' Returns the requested values of the datastore
:param address: The starting address
:param count: The number of values to retrieve
:returns: The requested values from a:a+c
'''
start = address - self.address
return self.values[start:start + count]
def setValues(self, address, values):
''' Sets the requested values of the datastore
:param address: The starting address
:param values: The new values to be set
'''
if not isinstance(values, list):
values = [values]
start = address - self.address
self.values[start:start + len(values)] = values
class ModbusSparseDataBlock(BaseModbusDataBlock):
''' Creates a sparse modbus datastore '''
def __init__(self, values):
''' Initializes the datastore
Using the input values we create the default
datastore value and the starting address
:param values: Either a list or a dictionary of values
'''
if isinstance(values, dict):
self.values = values
elif hasattr(values, '__iter__'):
self.values = dict(enumerate(values))
else: raise ParameterException(
"Values for datastore must be a list or dictionary")
self.default_value = get_next(itervalues(self.values)).__class__()
self.address = get_next(iterkeys(self.values))
@classmethod
def create(klass):
''' Factory method to create a datastore with the
full address space initialized to 0x00
:returns: An initialized datastore
'''
return klass([0x00] * 65536)
def validate(self, address, count=1):
''' Checks to see if the request is in range
:param address: The starting address
:param count: The number of values to test for
:returns: True if the request in within range, False otherwise
'''
if count == 0: return False
handle = set(range(address, address + count))
return handle.issubset(set(iterkeys(self.values)))
def getValues(self, address, count=1):
''' Returns the requested values of the datastore
:param address: The starting address
:param count: The number of values to retrieve
:returns: The requested values from a:a+c
'''
return [self.values[i] for i in range(address, address + count)]
def setValues(self, address, values):
''' Sets the requested values of the datastore
:param address: The starting address
:param values: The new values to be set
'''
if isinstance(values, dict):
for idx, val in iteritems(values):
self.values[idx] = val
else:
if not isinstance(values, list):
values = [values]
for idx, val in enumerate(values):
self.values[address + idx] = val
pymodbus-1.3.2/pymodbus/datastore/context.py 0000644 0001750 0001750 00000013432 13150360615 017404 0 ustar wmb wmb from pymodbus.exceptions import ParameterException, NoSuchSlaveException
from pymodbus.interfaces import IModbusSlaveContext
from pymodbus.datastore.store import ModbusSequentialDataBlock
from pymodbus.constants import Defaults
from pymodbus.compat import iteritems, itervalues
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Slave Contexts
#---------------------------------------------------------------------------#
class ModbusSlaveContext(IModbusSlaveContext):
'''
This creates a modbus data model with each data access
stored in its own personal block
'''
def __init__(self, *args, **kwargs):
''' Initializes the datastores, defaults to fully populated
sequential data blocks if none are passed in.
:param kwargs: Each element is a ModbusDataBlock
'di' - Discrete Inputs initializer
'co' - Coils initializer
'hr' - Holding Register initializer
'ir' - Input Registers iniatializer
'''
self.store = {}
self.store['d'] = kwargs.get('di', ModbusSequentialDataBlock.create())
self.store['c'] = kwargs.get('co', ModbusSequentialDataBlock.create())
self.store['i'] = kwargs.get('ir', ModbusSequentialDataBlock.create())
self.store['h'] = kwargs.get('hr', ModbusSequentialDataBlock.create())
self.zero_mode = kwargs.get('zero_mode', Defaults.ZeroMode)
def __str__(self):
''' Returns a string representation of the context
:returns: A string representation of the context
'''
return "Modbus Slave Context"
def reset(self):
''' Resets all the datastores to their default values '''
for datastore in itervalues(self.store):
datastore.reset()
def validate(self, fx, address, count=1):
''' Validates the request to make sure it is in range
:param fx: The function we are working with
:param address: The starting address
:param count: The number of values to test
:returns: True if the request in within range, False otherwise
'''
if not self.zero_mode: address = address + 1
_logger.debug("validate[%d] %d:%d" % (fx, address, count))
return self.store[self.decode(fx)].validate(address, count)
def getValues(self, fx, address, count=1):
''' Validates the request to make sure it is in range
:param fx: The function we are working with
:param address: The starting address
:param count: The number of values to retrieve
:returns: The requested values from a:a+c
'''
if not self.zero_mode: address = address + 1
_logger.debug("getValues[%d] %d:%d" % (fx, address, count))
return self.store[self.decode(fx)].getValues(address, count)
def setValues(self, fx, address, values):
''' Sets the datastore with the supplied values
:param fx: The function we are working with
:param address: The starting address
:param values: The new values to be set
'''
if not self.zero_mode: address = address + 1
_logger.debug("setValues[%d] %d:%d" % (fx, address, len(values)))
self.store[self.decode(fx)].setValues(address, values)
class ModbusServerContext(object):
''' This represents a master collection of slave contexts.
If single is set to true, it will be treated as a single
context so every unit-id returns the same context. If single
is set to false, it will be interpreted as a collection of
slave contexts.
'''
def __init__(self, slaves=None, single=True):
''' Initializes a new instance of a modbus server context.
:param slaves: A dictionary of client contexts
:param single: Set to true to treat this as a single context
'''
self.single = single
self.__slaves = slaves or {}
if self.single:
self.__slaves = {Defaults.UnitId: self.__slaves}
def __iter__(self):
''' Iterater over the current collection of slave
contexts.
:returns: An iterator over the slave contexts
'''
return iteritems(self.__slaves)
def __contains__(self, slave):
''' Check if the given slave is in this list
:param slave: slave The slave to check for existance
:returns: True if the slave exists, False otherwise
'''
return slave in self.__slaves
def __setitem__(self, slave, context):
''' Used to set a new slave context
:param slave: The slave context to set
:param context: The new context to set for this slave
'''
if self.single: slave = Defaults.UnitId
if 0xf7 >= slave >= 0x00:
self.__slaves[slave] = context
else:
raise NoSuchSlaveException('slave index :{} out of range'.format(slave))
def __delitem__(self, slave):
''' Wrapper used to access the slave context
:param slave: The slave context to remove
'''
if not self.single and (0xf7 >= slave >= 0x00):
del self.__slaves[slave]
else:
raise NoSuchSlaveException('slave index: {} out of range'.format(slave))
def __getitem__(self, slave):
''' Used to get access to a slave context
:param slave: The slave context to get
:returns: The requested slave context
'''
if self.single: slave = Defaults.UnitId
if slave in self.__slaves:
return self.__slaves.get(slave)
else:
raise NoSuchSlaveException("slave - {} does not exist, or is out of range".format(slave))
pymodbus-1.3.2/pymodbus/datastore/remote.py 0000644 0001750 0001750 00000007360 13150360615 017216 0 ustar wmb wmb from pymodbus.exceptions import NotImplementedException
from pymodbus.interfaces import IModbusSlaveContext
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Context
#---------------------------------------------------------------------------#
class RemoteSlaveContext(IModbusSlaveContext):
''' TODO
This creates a modbus data model that connects to
a remote device (depending on the client used)
'''
def __init__(self, client):
''' Initializes the datastores
:param client: The client to retrieve values with
'''
self._client = client
self.__build_mapping()
def reset(self):
''' Resets all the datastores to their default values '''
raise NotImplementedException()
def validate(self, fx, address, count=1):
''' Validates the request to make sure it is in range
:param fx: The function we are working with
:param address: The starting address
:param count: The number of values to test
:returns: True if the request in within range, False otherwise
'''
_logger.debug("validate[%d] %d:%d" % (fx, address, count))
result = self.__get_callbacks[self.decode(fx)](address, count)
return result.function_code < 0x80
def getValues(self, fx, address, count=1):
''' Validates the request to make sure it is in range
:param fx: The function we are working with
:param address: The starting address
:param count: The number of values to retrieve
:returns: The requested values from a:a+c
'''
# TODO deal with deferreds
_logger.debug("get values[%d] %d:%d" % (fx, address, count))
result = self.__get_callbacks[self.decode(fx)](address, count)
return self.__extract_result(self.decode(fx), result)
def setValues(self, fx, address, values):
''' Sets the datastore with the supplied values
:param fx: The function we are working with
:param address: The starting address
:param values: The new values to be set
'''
# TODO deal with deferreds
_logger.debug("set values[%d] %d:%d" % (fx, address, len(values)))
self.__set_callbacks[self.decode(fx)](address, values)
def __str__(self):
''' Returns a string representation of the context
:returns: A string representation of the context
'''
return "Remote Slave Context(%s)" % self._client
def __build_mapping(self):
'''
A quick helper method to build the function
code mapper.
'''
self.__get_callbacks = {
'd': lambda a, c: self._client.read_discrete_inputs(a, c),
'c': lambda a, c: self._client.read_coils(a, c),
'h': lambda a, c: self._client.read_holding_registers(a, c),
'i': lambda a, c: self._client.read_input_registers(a, c),
}
self.__set_callbacks = {
'd': lambda a, v: self._client.write_coils(a, v),
'c': lambda a, v: self._client.write_coils(a, v),
'h': lambda a, v: self._client.write_registers(a, v),
'i': lambda a, v: self._client.write_registers(a, v),
}
def __extract_result(self, fx, result):
''' A helper method to extract the values out of
a response. TODO make this consistent (values?)
'''
if result.function_code < 0x80:
if fx in ['d', 'c']: return result.bits
if fx in ['h', 'i']: return result.registers
else: return result
pymodbus-1.3.2/pymodbus/bit_read_message.py 0000644 0001750 0001750 00000020606 13150360615 017210 0 ustar wmb wmb """
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
from pymodbus.compat import byte2int
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 get_response_pdu_size(self):
"""
Func_code (1 byte) + Byte Count(1 byte) + Quantity of Coils (n Bytes)/8,
if the remainder is different of 0 then N = N+1
:return:
"""
count = self.count//8
if self.count % 8:
count += 1
return 1 + 1 + count
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 = byte2int(data[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-1.3.2/pymodbus/register_write_message.py 0000644 0001750 0001750 00000027127 13150360615 020502 0 ustar wmb wmb '''
Register Writing Request/Response Messages
-------------------------------------------
'''
import struct
from pymodbus.pdu import ModbusRequest
from pymodbus.pdu import ModbusResponse
from pymodbus.pdu import ModbusExceptions as merror
class WriteSingleRegisterRequest(ModbusRequest):
'''
This function code is used to write a single holding register in a
remote device.
The Request PDU specifies the address of the register to
be written. Registers are addressed starting at zero. Therefore register
numbered 1 is addressed as 0.
'''
function_code = 6
_rtu_frame_size = 8
def __init__(self, address=None, value=None, **kwargs):
''' Initializes a new instance
:param address: The address to start writing add
:param value: The values to write
'''
ModbusRequest.__init__(self, **kwargs)
self.address = address
self.value = value
def encode(self):
''' Encode a write single register packet packet request
:returns: The encoded packet
'''
packet = struct.pack('>H', self.address)
if self.skip_encode:
packet += self.value
else:
packet += struct.pack('>H', self.value)
return packet
def decode(self, data):
''' Decode a write single register packet packet request
:param data: The request to decode
'''
self.address, self.value = struct.unpack('>HH', data)
def execute(self, context):
''' Run a write single register request against a datastore
:param context: The datastore to request from
:returns: An initialized response, exception message otherwise
'''
if not (0 <= self.value <= 0xffff):
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 WriteSingleRegisterResponse(self.address, values[0])
def get_response_pdu_size(self):
"""
Func_code (1 byte) + Register Address(2 byte) + Register Value (2 bytes)
:return:
"""
return 1 + 2 + 2
def __str__(self):
''' Returns a string representation of the instance
:returns: A string representation of the instance
'''
return "WriteRegisterRequest %d" % self.address
class WriteSingleRegisterResponse(ModbusResponse):
'''
The normal response is an echo of the request, returned after the
register contents have been written.
'''
function_code = 6
_rtu_frame_size = 8
def __init__(self, address=None, value=None, **kwargs):
''' Initializes a new instance
:param address: The address to start writing add
:param value: The values to write
'''
ModbusResponse.__init__(self, **kwargs)
self.address = address
self.value = value
def encode(self):
''' Encode a write single register packet packet request
:returns: The encoded packet
'''
return struct.pack('>HH', self.address, self.value)
def decode(self, data):
''' Decode a write single register packet packet request
:param data: The request to decode
'''
self.address, self.value = struct.unpack('>HH', data)
def __str__(self):
''' Returns a string representation of the instance
:returns: A string representation of the instance
'''
params = (self.address, self.value)
return "WriteRegisterResponse %d => %d" % params
#---------------------------------------------------------------------------#
# Write Multiple Registers
#---------------------------------------------------------------------------#
class WriteMultipleRegistersRequest(ModbusRequest):
'''
This function code is used to write a block of contiguous registers (1
to approx. 120 registers) in a remote device.
The requested written values are specified in the request data field.
Data is packed as two bytes per register.
'''
function_code = 16
_rtu_byte_count_pos = 6
_pdu_length = 5 #func + adress1 + adress2 + outputQuant1 + outputQuant2
def __init__(self, address=None, values=None, **kwargs):
''' Initializes a new instance
:param address: The address to start writing to
:param values: The values to write
'''
ModbusRequest.__init__(self, **kwargs)
self.address = address
if values is None:
values = []
elif not hasattr(values, '__iter__'):
values = [values]
self.values = values
self.count = len(self.values)
self.byte_count = self.count * 2
def encode(self):
''' Encode a write single register packet packet request
:returns: The encoded packet
'''
packet = struct.pack('>HHB', self.address, self.count, self.byte_count)
if self.skip_encode:
return packet + b''.join(self.values)
for value in self.values:
packet += struct.pack('>H', value)
return packet
def decode(self, data):
''' Decode a write single register packet packet request
:param data: The request to decode
'''
self.address, self.count, \
self.byte_count = struct.unpack('>HHB', data[:5])
self.values = [] # reset
for idx in range(5, (self.count * 2) + 5, 2):
self.values.append(struct.unpack('>H', data[idx:idx + 2])[0])
def execute(self, context):
''' Run a write single register request against a datastore
:param context: The datastore to request from
:returns: An initialized response, exception message otherwise
'''
if not (1 <= self.count <= 0x07b):
return self.doException(merror.IllegalValue)
if (self.byte_count != self.count * 2):
return self.doException(merror.IllegalValue)
if not context.validate(self.function_code, self.address, self.count):
return self.doException(merror.IllegalAddress)
context.setValues(self.function_code, self.address, self.values)
return WriteMultipleRegistersResponse(self.address, self.count)
def __str__(self):
''' Returns a string representation of the instance
:returns: A string representation of the instance
'''
params = (self.address, self.count)
return "WriteMultipleRegisterRequest %d => %d" % params
class WriteMultipleRegistersResponse(ModbusResponse):
'''
"The normal response returns the function code, starting address, and
quantity of registers written.
'''
function_code = 16
_rtu_frame_size = 8
def __init__(self, address=None, count=None, **kwargs):
''' Initializes a new instance
:param address: The address to start writing to
:param count: The number of registers to write to
'''
ModbusResponse.__init__(self, **kwargs)
self.address = address
self.count = count
def encode(self):
''' Encode a write single register packet packet request
:returns: The encoded packet
'''
return struct.pack('>HH', self.address, self.count)
def decode(self, data):
''' Decode a write single register packet packet request
:param data: The request 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
'''
params = (self.address, self.count)
return "WriteMultipleRegisterResponse (%d,%d)" % params
class MaskWriteRegisterRequest(ModbusRequest):
'''
This function code is used to modify the contents of a specified holding
register using a combination of an AND mask, an OR mask, and the
register's current contents. The function can be used to set or clear
individual bits in the register.
'''
function_code = 0x16
_rtu_frame_size = 10
def __init__(self, address=0x0000, and_mask=0xffff, or_mask=0x0000,
**kwargs):
''' Initializes a new instance
:param address: The mask pointer address (0x0000 to 0xffff)
:param and_mask: The and bitmask to apply to the register address
:param or_mask: The or bitmask to apply to the register address
'''
ModbusRequest.__init__(self, **kwargs)
self.address = address
self.and_mask = and_mask
self.or_mask = or_mask
def encode(self):
''' Encodes the request packet
:returns: The byte encoded packet
'''
return struct.pack('>HHH', self.address, self.and_mask,
self.or_mask)
def decode(self, data):
''' Decodes the incoming request
:param data: The data to decode into the address
'''
self.address, self.and_mask, self.or_mask = struct.unpack('>HHH',
data)
def execute(self, context):
''' Run a mask write register request against the store
:param context: The datastore to request from
:returns: The populated response
'''
if not (0x0000 <= self.and_mask <= 0xffff):
return self.doException(merror.IllegalValue)
if not (0x0000 <= self.or_mask <= 0xffff):
return self.doException(merror.IllegalValue)
if not context.validate(self.function_code, self.address, 1):
return self.doException(merror.IllegalAddress)
values = context.getValues(self.function_code, self.address, 1)[0]
values = ((values & self.and_mask) | self.or_mask)
context.setValues(self.function_code, self.address, [values])
return MaskWriteRegisterResponse(self.address, self.and_mask,
self.or_mask)
class MaskWriteRegisterResponse(ModbusResponse):
'''
The normal response is an echo of the request. The response is returned
after the register has been written.
'''
function_code = 0x16
_rtu_frame_size = 10
def __init__(self, address=0x0000, and_mask=0xffff, or_mask=0x0000,
**kwargs):
''' Initializes a new instance
:param address: The mask pointer address (0x0000 to 0xffff)
:param and_mask: The and bitmask applied to the register address
:param or_mask: The or bitmask applied to the register address
'''
ModbusResponse.__init__(self, **kwargs)
self.address = address
self.and_mask = and_mask
self.or_mask = or_mask
def encode(self):
''' Encodes the response
:returns: The byte encoded message
'''
return struct.pack('>HHH', self.address, self.and_mask,
self.or_mask)
def decode(self, data):
''' Decodes a the response
:param data: The packet data to decode
'''
self.address, self.and_mask, self.or_mask = struct.unpack('>HHH',
data)
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"WriteSingleRegisterRequest", "WriteSingleRegisterResponse",
"WriteMultipleRegistersRequest", "WriteMultipleRegistersResponse",
"MaskWriteRegisterRequest", "MaskWriteRegisterResponse"
]
pymodbus-1.3.2/pymodbus/internal/ 0000755 0001750 0001750 00000000000 13150360615 015171 5 ustar wmb wmb pymodbus-1.3.2/pymodbus/internal/__init__.py 0000644 0001750 0001750 00000000000 13150360615 017270 0 ustar wmb wmb pymodbus-1.3.2/pymodbus/internal/ptwisted.py 0000644 0001750 0001750 00000002720 13150360615 017407 0 ustar wmb wmb '''
A collection of twisted utility code
'''
from pymodbus.compat import IS_PYTHON2, IS_PYTHON3
if IS_PYTHON2:
from twisted.cred import portal, checkers
from twisted.conch import manhole, manhole_ssh
from twisted.conch.insults import insults
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Twisted Helper Methods
#---------------------------------------------------------------------------#
def InstallManagementConsole(namespace, users={'admin': 'admin'}, port=503):
''' Helper method to start an ssh management console
for the modbus server.
:param namespace: The data to constrain the server to
:param users: The users to login with
:param port: The port to host the server on
'''
if IS_PYTHON3:
raise NotImplemented("This code currently doesn't work on python3")
from twisted.internet import reactor
def build_protocol():
p = insults.ServerProtocol(manhole.ColoredManhole, namespace)
return p
r = manhole_ssh.TerminalRealm()
r.chainedProtocolFactory = build_protocol
c = checkers.InMemoryUsernamePasswordDatabaseDontUse(**users)
p = portal.Portal(r, [c])
factory = manhole_ssh.ConchFactory(p)
reactor.listenTCP(port, factory)
pymodbus-1.3.2/pymodbus/other_message.py 0000644 0001750 0001750 00000034403 13150360615 016560 0 ustar wmb wmb '''
Diagnostic record read/write
Currently not all implemented
'''
import struct
from pymodbus.constants import ModbusStatus
from pymodbus.pdu import ModbusRequest
from pymodbus.pdu import ModbusResponse
from pymodbus.device import ModbusControlBlock
from pymodbus.compat import byte2int, int2byte
_MCB = ModbusControlBlock()
#---------------------------------------------------------------------------#
# TODO Make these only work on serial
#---------------------------------------------------------------------------#
class ReadExceptionStatusRequest(ModbusRequest):
'''
This function code is used to read the contents of eight Exception Status
outputs in a remote device. The function provides a simple method for
accessing this information, because the Exception Output references are
known (no output reference is needed in the function).
'''
function_code = 0x07
_rtu_frame_size = 4
def __init__(self, **kwargs):
''' Initializes a new instance
'''
ModbusRequest.__init__(self, **kwargs)
def encode(self):
''' Encodes the message
'''
return b''
def decode(self, data):
''' Decodes data part of the message.
:param data: The incoming data
'''
pass
def execute(self, context=None):
''' Run a read exeception status request against the store
:returns: The populated response
'''
status = _MCB.Counter.summary()
return ReadExceptionStatusResponse(status)
def __str__(self):
''' Builds a representation of the request
:returns: The string representation of the request
'''
return "ReadExceptionStatusRequest(%d)" % (self.function_code)
class ReadExceptionStatusResponse(ModbusResponse):
'''
The normal response contains the status of the eight Exception Status
outputs. The outputs are packed into one data byte, with one bit
per output. The status of the lowest output reference is contained
in the least significant bit of the byte. The contents of the eight
Exception Status outputs are device specific.
'''
function_code = 0x07
_rtu_frame_size = 5
def __init__(self, status=0x00, **kwargs):
''' Initializes a new instance
:param status: The status response to report
'''
ModbusResponse.__init__(self, **kwargs)
self.status = status
def encode(self):
''' Encodes the response
:returns: The byte encoded message
'''
return struct.pack('>B', self.status)
def decode(self, data):
''' Decodes a the response
:param data: The packet data to decode
'''
self.status = byte2int(data[0])
def __str__(self):
''' Builds a representation of the response
:returns: The string representation of the response
'''
arguments = (self.function_code, self.status)
return "ReadExceptionStatusResponse(%d, %s)" % arguments
# Encapsulate interface transport 43, 14
# CANopen general reference 43, 13
#---------------------------------------------------------------------------#
# TODO Make these only work on serial
#---------------------------------------------------------------------------#
class GetCommEventCounterRequest(ModbusRequest):
'''
This function code is used to get a status word and an event count from
the remote device's communication event counter.
By fetching the current count before and after a series of messages, a
client can determine whether the messages were handled normally by the
remote device.
The device's event counter is incremented once for each successful
message completion. It is not incremented for exception responses,
poll commands, or fetch event counter commands.
The event counter can be reset by means of the Diagnostics function
(code 08), with a subfunction of Restart Communications Option
(code 00 01) or Clear Counters and Diagnostic Register (code 00 0A).
'''
function_code = 0x0b
_rtu_frame_size = 4
def __init__(self, **kwargs):
''' Initializes a new instance
'''
ModbusRequest.__init__(self, **kwargs)
def encode(self):
''' Encodes the message
'''
return b''
def decode(self, data):
''' Decodes data part of the message.
:param data: The incoming data
'''
pass
def execute(self, context=None):
''' Run a read exeception status request against the store
:returns: The populated response
'''
status = _MCB.Counter.Event
return GetCommEventCounterResponse(status)
def __str__(self):
''' Builds a representation of the request
:returns: The string representation of the request
'''
return "GetCommEventCounterRequest(%d)" % (self.function_code)
class GetCommEventCounterResponse(ModbusResponse):
'''
The normal response contains a two-byte status word, and a two-byte
event count. The status word will be all ones (FF FF hex) if a
previously-issued program command is still being processed by the
remote device (a busy condition exists). Otherwise, the status word
will be all zeros.
'''
function_code = 0x0b
_rtu_frame_size = 8
def __init__(self, count=0x0000, **kwargs):
''' Initializes a new instance
:param count: The current event counter value
'''
ModbusResponse.__init__(self, **kwargs)
self.count = count
self.status = True # this means we are ready, not waiting
def encode(self):
''' Encodes the response
:returns: The byte encoded message
'''
if self.status: ready = ModbusStatus.Ready
else: ready = ModbusStatus.Waiting
return struct.pack('>HH', ready, self.count)
def decode(self, data):
''' Decodes a the response
:param data: The packet data to decode
'''
ready, self.count = struct.unpack('>HH', data)
self.status = (ready == ModbusStatus.Ready)
def __str__(self):
''' Builds a representation of the response
:returns: The string representation of the response
'''
arguments = (self.function_code, self.count, self.status)
return "GetCommEventCounterResponse(%d, %d, %d)" % arguments
#---------------------------------------------------------------------------#
# TODO Make these only work on serial
#---------------------------------------------------------------------------#
class GetCommEventLogRequest(ModbusRequest):
'''
This function code is used to get a status word, event count, message
count, and a field of event bytes from the remote device.
The status word and event counts are identical to that returned by
the Get Communications Event Counter function (11, 0B hex).
The message counter contains the quantity of messages processed by the
remote device since its last restart, clear counters operation, or
power-up. This count is identical to that returned by the Diagnostic
function (code 08), sub-function Return Bus Message Count (code 11,
0B hex).
The event bytes field contains 0-64 bytes, with each byte corresponding
to the status of one MODBUS send or receive operation for the remote
device. The remote device enters the events into the field in
chronological order. Byte 0 is the most recent event. Each new byte
flushes the oldest byte from the field.
'''
function_code = 0x0c
_rtu_frame_size = 4
def __init__(self, **kwargs):
''' Initializes a new instance
'''
ModbusRequest.__init__(self, **kwargs)
def encode(self):
''' Encodes the message
'''
return b''
def decode(self, data):
''' Decodes data part of the message.
:param data: The incoming data
'''
pass
def execute(self, context=None):
''' Run a read exeception status request against the store
:returns: The populated response
'''
results = {
'status' : True,
'message_count' : _MCB.Counter.BusMessage,
'event_count' : _MCB.Counter.Event,
'events' : _MCB.getEvents(),
}
return GetCommEventLogResponse(**results)
def __str__(self):
''' Builds a representation of the request
:returns: The string representation of the request
'''
return "GetCommEventLogRequest(%d)" % self.function_code
class GetCommEventLogResponse(ModbusResponse):
'''
The normal response contains a two-byte status word field,
a two-byte event count field, a two-byte message count field,
and a field containing 0-64 bytes of events. A byte count
field defines the total length of the data in these four field
'''
function_code = 0x0c
_rtu_byte_count_pos = 3
def __init__(self, **kwargs):
''' Initializes a new instance
:param status: The status response to report
:param message_count: The current message count
:param event_count: The current event count
:param events: The collection of events to send
'''
ModbusResponse.__init__(self, **kwargs)
self.status = kwargs.get('status', True)
self.message_count = kwargs.get('message_count', 0)
self.event_count = kwargs.get('event_count', 0)
self.events = kwargs.get('events', [])
def encode(self):
''' Encodes the response
:returns: The byte encoded message
'''
if self.status: ready = ModbusStatus.Ready
else: ready = ModbusStatus.Waiting
packet = struct.pack('>B', 6 + len(self.events))
packet += struct.pack('>H', ready)
packet += struct.pack('>HH', self.event_count, self.message_count)
packet += b''.join(struct.pack('>B', e) for e in self.events)
return packet
def decode(self, data):
''' Decodes a the response
:param data: The packet data to decode
'''
length = byte2int(data[0])
status = struct.unpack('>H', data[1:3])[0]
self.status = (status == ModbusStatus.Ready)
self.event_count = struct.unpack('>H', data[3:5])[0]
self.message_count = struct.unpack('>H', data[5:7])[0]
self.events = []
for e in range(7, length + 1):
self.events.append(byte2int(data[e]))
def __str__(self):
''' Builds a representation of the response
:returns: The string representation of the response
'''
arguments = (self.function_code, self.status, self.message_count, self.event_count)
return "GetCommEventLogResponse(%d, %d, %d, %d)" % arguments
#---------------------------------------------------------------------------#
# TODO Make these only work on serial
#---------------------------------------------------------------------------#
class ReportSlaveIdRequest(ModbusRequest):
'''
This function code is used to read the description of the type, the
current status, and other information specific to a remote device.
'''
function_code = 0x11
_rtu_frame_size = 4
def __init__(self, **kwargs):
''' Initializes a new instance
'''
ModbusRequest.__init__(self, **kwargs)
def encode(self):
''' Encodes the message
'''
return b''
def decode(self, data):
''' Decodes data part of the message.
:param data: The incoming data
'''
pass
def execute(self, context=None):
''' Run a read exeception status request against the store
:returns: The populated response
'''
identifier = b'Pymodbus'
return ReportSlaveIdResponse(identifier)
def __str__(self):
''' Builds a representation of the request
:returns: The string representation of the request
'''
return "ResportSlaveIdRequest(%d)" % self.function_code
class ReportSlaveIdResponse(ModbusResponse):
'''
The format of a normal response is shown in the following example.
The data contents are specific to each type of device.
'''
function_code = 0x11
_rtu_byte_count_pos = 2
def __init__(self, identifier=b'\x00', status=True, **kwargs):
''' Initializes a new instance
:param identifier: The identifier of the slave
:param status: The status response to report
'''
ModbusResponse.__init__(self, **kwargs)
self.identifier = identifier
self.status = status
self.byte_count = None
def encode(self):
''' Encodes the response
:returns: The byte encoded message
'''
if self.status:
status = ModbusStatus.SlaveOn
else:
status = ModbusStatus.SlaveOff
length = len(self.identifier) + 1
packet = int2byte(length)
packet += self.identifier # we assume it is already encoded
packet += int2byte(status)
return packet
def decode(self, data):
''' Decodes a the response
Since the identifier is device dependent, we just return the
raw value that a user can decode to whatever it should be.
:param data: The packet data to decode
'''
self.byte_count = byte2int(data[0])
self.identifier = data[1:self.byte_count + 1]
status = byte2int(data[-1])
self.status = status == ModbusStatus.SlaveOn
def __str__(self):
''' Builds a representation of the response
:returns: The string representation of the response
'''
arguments = (self.function_code, self.identifier, self.status)
return "ResportSlaveIdResponse(%s, %s, %s)" % arguments
#---------------------------------------------------------------------------#
# TODO Make these only work on serial
#---------------------------------------------------------------------------#
# report device identification 43, 14
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"ReadExceptionStatusRequest", "ReadExceptionStatusResponse",
"GetCommEventCounterRequest", "GetCommEventCounterResponse",
"GetCommEventLogRequest", "GetCommEventLogResponse",
"ReportSlaveIdRequest", "ReportSlaveIdResponse",
]
pymodbus-1.3.2/pymodbus/constants.py 0000644 0001750 0001750 00000014711 13150360615 015747 0 ustar wmb wmb '''
Constants For Modbus Server/Client
----------------------------------
This is the single location for storing default
values for the servers and clients.
'''
from pymodbus.interfaces import Singleton
class Defaults(Singleton):
''' A collection of modbus default values
.. attribute:: Port
The default modbus tcp server port (502)
.. attribute:: Retries
The default number of times a client should retry the given
request before failing (3)
.. attribute:: RetryOnEmpty
A flag indicating if a transaction should be retried in the
case that an empty response is received. This is useful for
slow clients that may need more time to process a requst.
.. attribute:: Timeout
The default amount of time a client should wait for a request
to be processed (3 seconds)
.. attribute:: Reconnects
The default number of times a client should attempt to reconnect
before deciding the server is down (0)
.. attribute:: TransactionId
The starting transaction identifier number (0)
.. attribute:: ProtocolId
The modbus protocol id. Currently this is set to 0 in all
but proprietary implementations.
.. attribute:: UnitId
The modbus slave addrss. Currently this is set to 0x00 which
means this request should be broadcast to all the slave devices
(really means that all the devices should respons).
.. attribute:: Baudrate
The speed at which the data is transmitted over the serial line.
This defaults to 19200.
.. attribute:: Parity
The type of checksum to use to verify data integrity. This can be
on of the following::
- (E)ven - 1 0 1 0 | P(0)
- (O)dd - 1 0 1 0 | P(1)
- (N)one - 1 0 1 0 | no parity
This defaults to (N)one.
.. attribute:: Bytesize
The number of bits in a byte of serial data. This can be one of
5, 6, 7, or 8. This defaults to 8.
.. attribute:: Stopbits
The number of bits sent after each character in a message to
indicate the end of the byte. This defaults to 1.
.. attribute:: ZeroMode
Indicates if the slave datastore should use indexing at 0 or 1.
More about this can be read in section 4.4 of the modbus specification.
.. attribute:: IgnoreMissingSlaves
In case a request is made to a missing slave, this defines if an error
should be returned or simply ignored. This is useful for the case of a
serial server emulater where a request to a non-existant slave on a bus
will never respond. The client in this case will simply timeout.
'''
Port = 502
Retries = 3
RetryOnEmpty = False
Timeout = 3
Reconnects = 0
TransactionId = 0
ProtocolId = 0
UnitId = 0x00
Baudrate = 19200
Parity = 'N'
Bytesize = 8
Stopbits = 1
ZeroMode = False
IgnoreMissingSlaves = False
class ModbusStatus(Singleton):
'''
These represent various status codes in the modbus
protocol.
.. attribute:: Waiting
This indicates that a modbus device is currently
waiting for a given request to finish some running task.
.. attribute:: Ready
This indicates that a modbus device is currently
free to perform the next request task.
.. attribute:: On
This indicates that the given modbus entity is on
.. attribute:: Off
This indicates that the given modbus entity is off
.. attribute:: SlaveOn
This indicates that the given modbus slave is running
.. attribute:: SlaveOff
This indicates that the given modbus slave is not running
'''
Waiting = 0xffff
Ready = 0x0000
On = 0xff00
Off = 0x0000
SlaveOn = 0xff
SlaveOff = 0x00
class Endian(Singleton):
''' An enumeration representing the various byte endianess.
.. attribute:: Auto
This indicates that the byte order is chosen by the
current native environment.
.. attribute:: Big
This indicates that the bytes are in little endian format
.. attribute:: Little
This indicates that the bytes are in big endian format
.. note:: I am simply borrowing the format strings from the
python struct module for my convenience.
'''
Auto = '@'
Big = '>'
Little = '<'
class ModbusPlusOperation(Singleton):
''' Represents the type of modbus plus request
.. attribute:: GetStatistics
Operation requesting that the current modbus plus statistics
be returned in the response.
.. attribute:: ClearStatistics
Operation requesting that the current modbus plus statistics
be cleared and not returned in the response.
'''
GetStatistics = 0x0003
ClearStatistics = 0x0004
class DeviceInformation(Singleton):
''' Represents what type of device information to read
.. attribute:: Basic
This is the basic (required) device information to be returned.
This includes VendorName, ProductCode, and MajorMinorRevision
code.
.. attribute:: Regular
In addition to basic data objects, the device provides additional
and optinoal identification and description data objects. All of
the objects of this category are defined in the standard but their
implementation is optional.
.. attribute:: Extended
In addition to regular data objects, the device provides additional
and optional identification and description private data about the
physical device itself. All of these data are device dependent.
.. attribute:: Specific
Request to return a single data object.
'''
Basic = 0x01
Regular = 0x02
Extended = 0x03
Specific = 0x04
class MoreData(Singleton):
''' Represents the more follows condition
.. attribute:: Nothing
This indiates that no more objects are going to be returned.
.. attribute:: KeepReading
This indicates that there are more objects to be returned.
'''
Nothing = 0x00
KeepReading = 0xFF
#---------------------------------------------------------------------------#
# Exported Identifiers
#---------------------------------------------------------------------------#
__all__ = [
"Defaults", "ModbusStatus", "Endian",
"ModbusPlusOperation",
"DeviceInformation", "MoreData",
]
pymodbus-1.3.2/pymodbus/payload.py 0000644 0001750 0001750 00000027254 13150360615 015372 0 ustar wmb wmb '''
Modbus Payload Builders
------------------------
A collection of utilities for building and decoding
modbus messages payloads.
'''
from struct import pack, unpack
from pymodbus.interfaces import IPayloadBuilder
from pymodbus.constants import Endian
from pymodbus.utilities import pack_bitstring
from pymodbus.utilities import unpack_bitstring
from pymodbus.utilities import make_byte_string
from pymodbus.exceptions import ParameterException
class BinaryPayloadBuilder(IPayloadBuilder):
'''
A utility that helps build payload messages to be
written with the various modbus messages. It really is just
a simple wrapper around the struct module, however it saves
time looking up the format strings. What follows is a simple
example::
builder = BinaryPayloadBuilder(endian=Endian.Little)
builder.add_8bit_uint(1)
builder.add_16bit_uint(2)
payload = builder.build()
'''
def __init__(self, payload=None, endian=Endian.Little):
''' Initialize a new instance of the payload builder
:param payload: Raw binary payload data to initialize with
:param endian: The endianess of the payload
'''
self._payload = payload or []
self._endian = endian
def to_string(self):
''' Return the payload buffer as a string
:returns: The payload buffer as a string
'''
return b''.join(self._payload)
def __str__(self):
''' Return the payload buffer as a string
:returns: The payload buffer as a string
'''
return self.to_string().decode('utf-8')
def reset(self):
''' Reset the payload buffer
'''
self._payload = []
def to_registers(self):
''' Convert the payload buffer into a register
layout that can be used as a context block.
:returns: The register layout to use as a block
'''
fstring = self._endian + 'H'
payload = self.build()
return [unpack(fstring, value)[0] for value in payload]
def build(self):
''' Return the payload buffer as a list
This list is two bytes per element and can
thus be treated as a list of registers.
:returns: The payload buffer as a list
'''
string = self.to_string()
length = len(string)
string = string + (b'\x00' * (length % 2))
return [string[i:i+2] for i in range(0, length, 2)]
def add_bits(self, values):
''' Adds a collection of bits to be encoded
If these are less than a multiple of eight,
they will be left padded with 0 bits to make
it so.
:param value: The value to add to the buffer
'''
value = pack_bitstring(values)
self._payload.append(value)
def add_8bit_uint(self, value):
''' Adds a 8 bit unsigned int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'B'
self._payload.append(pack(fstring, value))
def add_16bit_uint(self, value):
''' Adds a 16 bit unsigned int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'H'
self._payload.append(pack(fstring, value))
def add_32bit_uint(self, value):
''' Adds a 32 bit unsigned int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'I'
self._payload.append(pack(fstring, value))
def add_64bit_uint(self, value):
''' Adds a 64 bit unsigned int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'Q'
self._payload.append(pack(fstring, value))
def add_8bit_int(self, value):
''' Adds a 8 bit signed int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'b'
self._payload.append(pack(fstring, value))
def add_16bit_int(self, value):
''' Adds a 16 bit signed int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'h'
self._payload.append(pack(fstring, value))
def add_32bit_int(self, value):
''' Adds a 32 bit signed int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'i'
self._payload.append(pack(fstring, value))
def add_64bit_int(self, value):
''' Adds a 64 bit signed int to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'q'
self._payload.append(pack(fstring, value))
def add_32bit_float(self, value):
''' Adds a 32 bit float to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'f'
self._payload.append(pack(fstring, value))
def add_64bit_float(self, value):
''' Adds a 64 bit float(double) to the buffer
:param value: The value to add to the buffer
'''
fstring = self._endian + 'd'
self._payload.append(pack(fstring, value))
def add_string(self, value):
''' Adds a string to the buffer
:param value: The value to add to the buffer
'''
value = make_byte_string(value)
fstring = self._endian + str(len(value)) + 's'
self._payload.append(pack(fstring, value))
class BinaryPayloadDecoder(object):
'''
A utility that helps decode payload messages from a modbus
reponse message. It really is just a simple wrapper around
the struct module, however it saves time looking up the format
strings. What follows is a simple example::
decoder = BinaryPayloadDecoder(payload)
first = decoder.decode_8bit_uint()
second = decoder.decode_16bit_uint()
'''
def __init__(self, payload, endian=Endian.Little):
''' Initialize a new payload decoder
:param payload: The payload to decode with
:param endian: The endianess of the payload
'''
self._payload = payload
self._pointer = 0x00
self._endian = endian
@classmethod
def fromRegisters(klass, registers, endian=Endian.Little):
''' Initialize a payload decoder with the result of
reading a collection of registers from a modbus device.
The registers are treated as a list of 2 byte values.
We have to do this because of how the data has already
been decoded by the rest of the library.
:param registers: The register results to initialize with
:param endian: The endianess of the payload
:returns: An initialized PayloadDecoder
'''
if isinstance(registers, list): # repack into flat binary
payload = b''.join(pack(endian + 'H', x) for x in registers)
return klass(payload, endian)
raise ParameterException('Invalid collection of registers supplied')
@classmethod
def fromCoils(klass, coils, endian=Endian.Little):
''' Initialize a payload decoder with the result of
reading a collection of coils from a modbus device.
The coils are treated as a list of bit(boolean) values.
:param coils: The coil results to initialize with
:param endian: The endianess of the payload
:returns: An initialized PayloadDecoder
'''
if isinstance(coils, list):
payload = pack_bitstring(coils)
return klass(payload, endian)
raise ParameterException('Invalid collection of coils supplied')
def reset(self):
''' Reset the decoder pointer back to the start
'''
self._pointer = 0x00
def decode_8bit_uint(self):
''' Decodes a 8 bit unsigned int from the buffer
'''
self._pointer += 1
fstring = self._endian + 'B'
handle = self._payload[self._pointer - 1:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_bits(self):
''' Decodes a byte worth of bits from the buffer
'''
self._pointer += 1
# fstring = self._endian + 'B'
handle = self._payload[self._pointer - 1:self._pointer]
handle = make_byte_string(handle)
return unpack_bitstring(handle)
def decode_16bit_uint(self):
''' Decodes a 16 bit unsigned int from the buffer
'''
self._pointer += 2
fstring = self._endian + 'H'
handle = self._payload[self._pointer - 2:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_32bit_uint(self):
''' Decodes a 32 bit unsigned int from the buffer
'''
self._pointer += 4
fstring = self._endian + 'I'
handle = self._payload[self._pointer - 4:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_64bit_uint(self):
''' Decodes a 64 bit unsigned int from the buffer
'''
self._pointer += 8
fstring = self._endian + 'Q'
handle = self._payload[self._pointer - 8:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_8bit_int(self):
''' Decodes a 8 bit signed int from the buffer
'''
self._pointer += 1
fstring = self._endian + 'b'
handle = self._payload[self._pointer - 1:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_16bit_int(self):
''' Decodes a 16 bit signed int from the buffer
'''
self._pointer += 2
fstring = self._endian + 'h'
handle = self._payload[self._pointer - 2:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_32bit_int(self):
''' Decodes a 32 bit signed int from the buffer
'''
self._pointer += 4
fstring = self._endian + 'i'
handle = self._payload[self._pointer - 4:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_64bit_int(self):
''' Decodes a 64 bit signed int from the buffer
'''
self._pointer += 8
fstring = self._endian + 'q'
handle = self._payload[self._pointer - 8:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_32bit_float(self):
''' Decodes a 32 bit float from the buffer
'''
self._pointer += 4
fstring = self._endian + 'f'
handle = self._payload[self._pointer - 4:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_64bit_float(self):
''' Decodes a 64 bit float(double) from the buffer
'''
self._pointer += 8
fstring = self._endian + 'd'
handle = self._payload[self._pointer - 8:self._pointer]
handle = make_byte_string(handle)
return unpack(fstring, handle)[0]
def decode_string(self, size=1):
''' Decodes a string from the buffer
:param size: The size of the string to decode
'''
self._pointer += size
return self._payload[self._pointer - size:self._pointer]
def skip_bytes(self, nbytes):
''' Skip n bytes in the buffer
:param nbytes: The number of bytes to skip
'''
self._pointer += nbytes
return None
#---------------------------------------------------------------------------#
# Exported Identifiers
#---------------------------------------------------------------------------#
__all__ = ["BinaryPayloadBuilder", "BinaryPayloadDecoder"]
pymodbus-1.3.2/pymodbus/server/ 0000755 0001750 0001750 00000000000 13150360615 014663 5 ustar wmb wmb pymodbus-1.3.2/pymodbus/server/async.py 0000644 0001750 0001750 00000026101 13150360615 016352 0 ustar wmb wmb '''
Implementation of a Twisted Modbus Server
------------------------------------------
'''
from binascii import b2a_hex
from twisted.internet import protocol
from twisted.internet.protocol import ServerFactory
from pymodbus.constants import Defaults
from pymodbus.factory import ServerDecoder
from pymodbus.datastore import ModbusServerContext
from pymodbus.device import ModbusControlBlock
from pymodbus.device import ModbusAccessControl
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.exceptions import NoSuchSlaveException
from pymodbus.transaction import ModbusSocketFramer, ModbusAsciiFramer
from pymodbus.pdu import ModbusExceptions as merror
from pymodbus.internal.ptwisted import InstallManagementConsole
from pymodbus.compat import byte2int
from twisted.internet import reactor
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Modbus TCP Server
#---------------------------------------------------------------------------#
class ModbusTcpProtocol(protocol.Protocol):
''' Implements a modbus server in twisted '''
def connectionMade(self):
''' Callback for when a client connects
..note:: since the protocol factory cannot be accessed from the
protocol __init__, the client connection made is essentially
our __init__ method.
'''
_logger.debug("Client Connected [%s]" % self.transport.getHost())
self.framer = self.factory.framer(decoder=self.factory.decoder)
def connectionLost(self, reason):
''' Callback for when a client disconnects
:param reason: The client's reason for disconnecting
'''
_logger.debug("Client Disconnected: %s" % reason)
def dataReceived(self, data):
''' Callback when we receive any data
:param data: The data sent by the client
'''
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug(' '.join([hex(byte2int(x)) for x in data]))
if not self.factory.control.ListenOnly:
self.framer.processIncomingPacket(data, self._execute)
def _execute(self, request):
''' Executes the request and returns the result
:param request: The decoded request message
'''
try:
context = self.factory.store[request.unit_id]
response = request.execute(context)
except NoSuchSlaveException as ex:
_logger.debug("requested slave does not exist: %s" % request.unit_id )
if self.factory.ignore_missing_slaves:
return # the client will simply timeout waiting for a response
response = request.doException(merror.GatewayNoResponse)
except Exception as ex:
_logger.debug("Datastore unable to fulfill request: %s" % ex)
response = request.doException(merror.SlaveFailure)
#self.framer.populateResult(response)
response.transaction_id = request.transaction_id
response.unit_id = request.unit_id
self._send(response)
def _send(self, message):
''' Send a request (string) to the network
:param message: The unencoded modbus response
'''
if message.should_respond:
self.factory.control.Counter.BusMessage += 1
pdu = self.framer.buildPacket(message)
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug('send: %s' % b2a_hex(pdu))
return self.transport.write(pdu)
class ModbusServerFactory(ServerFactory):
'''
Builder class for a modbus server
This also holds the server datastore so that it is
persisted between connections
'''
protocol = ModbusTcpProtocol
def __init__(self, store, framer=None, identity=None, **kwargs):
''' Overloaded initializer for the modbus factory
If the identify structure is not passed in, the ModbusControlBlock
uses its own empty structure.
:param store: The ModbusServerContext datastore
:param framer: The framer strategy to use
:param identity: An optional identify structure
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
self.decoder = ServerDecoder()
self.framer = framer or ModbusSocketFramer
self.store = store or ModbusServerContext()
self.control = ModbusControlBlock()
self.access = ModbusAccessControl()
self.ignore_missing_slaves = kwargs.get('ignore_missing_slaves', Defaults.IgnoreMissingSlaves)
if isinstance(identity, ModbusDeviceIdentification):
self.control.Identity.update(identity)
#---------------------------------------------------------------------------#
# Modbus UDP Server
#---------------------------------------------------------------------------#
class ModbusUdpProtocol(protocol.DatagramProtocol):
''' Implements a modbus udp server in twisted '''
def __init__(self, store, framer=None, identity=None, **kwargs):
''' Overloaded initializer for the modbus factory
If the identify structure is not passed in, the ModbusControlBlock
uses its own empty structure.
:param store: The ModbusServerContext datastore
:param framer: The framer strategy to use
:param identity: An optional identify structure
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
framer = framer or ModbusSocketFramer
self.framer = framer(decoder=ServerDecoder())
self.store = store or ModbusServerContext()
self.control = ModbusControlBlock()
self.access = ModbusAccessControl()
self.ignore_missing_slaves = kwargs.get('ignore_missing_slaves', Defaults.IgnoreMissingSlaves)
if isinstance(identity, ModbusDeviceIdentification):
self.control.Identity.update(identity)
def datagramReceived(self, data, addr):
''' Callback when we receive any data
:param data: The data sent by the client
'''
_logger.debug("Client Connected [%s:%s]" % addr)
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug(" ".join([hex(byte2int(x)) for x in data]))
if not self.control.ListenOnly:
continuation = lambda request: self._execute(request, addr)
self.framer.processIncomingPacket(data, continuation)
def _execute(self, request, addr):
''' Executes the request and returns the result
:param request: The decoded request message
'''
try:
context = self.store[request.unit_id]
response = request.execute(context)
except NoSuchSlaveException as ex:
_logger.debug("requested slave does not exist: %s" % request.unit_id )
if self.ignore_missing_slaves:
return # the client will simply timeout waiting for a response
response = request.doException(merror.GatewayNoResponse)
except Exception as ex:
_logger.debug("Datastore unable to fulfill request: %s" % ex)
response = request.doException(merror.SlaveFailure)
#self.framer.populateResult(response)
response.transaction_id = request.transaction_id
response.unit_id = request.unit_id
self._send(response, addr)
def _send(self, message, addr):
''' Send a request (string) to the network
:param message: The unencoded modbus response
:param addr: The (host, port) to send the message to
'''
self.control.Counter.BusMessage += 1
pdu = self.framer.buildPacket(message)
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug('send: %s' % b2a_hex(pdu))
return self.transport.write(pdu, addr)
#---------------------------------------------------------------------------#
# Starting Factories
#---------------------------------------------------------------------------#
def StartTcpServer(context, identity=None, address=None, console=False, **kwargs):
''' Helper method to start the Modbus Async TCP server
:param context: The server data context
:param identify: The server identity to use (default empty)
:param address: An optional (interface, port) to bind to.
:param console: A flag indicating if you want the debug console
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
from twisted.internet import reactor
address = address or ("", Defaults.Port)
framer = ModbusSocketFramer
factory = ModbusServerFactory(context, framer, identity, **kwargs)
if console:
InstallManagementConsole({'factory': factory})
_logger.info("Starting Modbus TCP Server on %s:%s" % address)
reactor.listenTCP(address[1], factory, interface=address[0])
reactor.run()
def StartUdpServer(context, identity=None, address=None, **kwargs):
''' Helper method to start the Modbus Async Udp server
:param context: The server data context
:param identify: The server identity to use (default empty)
:param address: An optional (interface, port) to bind to.
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
from twisted.internet import reactor
address = address or ("", Defaults.Port)
framer = ModbusSocketFramer
server = ModbusUdpProtocol(context, framer, identity, **kwargs)
_logger.info("Starting Modbus UDP Server on %s:%s" % address)
reactor.listenUDP(address[1], server, interface=address[0])
reactor.run()
def StartSerialServer(context, identity=None,
framer=ModbusAsciiFramer, **kwargs):
''' Helper method to start the Modbus Async Serial server
:param context: The server data context
:param identify: The server identity to use (default empty)
:param framer: The framer to use (default ModbusAsciiFramer)
:param port: The serial port to attach to
:param baudrate: The baud rate to use for the serial device
:param console: A flag indicating if you want the debug console
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
from twisted.internet import reactor
from twisted.internet.serialport import SerialPort
port = kwargs.get('port', '/dev/ttyS0')
baudrate = kwargs.get('baudrate', Defaults.Baudrate)
console = kwargs.get('console', False)
_logger.info("Starting Modbus Serial Server on %s" % port)
factory = ModbusServerFactory(context, framer, identity, **kwargs)
if console:
InstallManagementConsole({'factory': factory})
protocol = factory.buildProtocol(None)
SerialPort.getHost = lambda self: port # hack for logging
SerialPort(protocol, port, reactor, baudrate)
reactor.run()
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"StartTcpServer", "StartUdpServer", "StartSerialServer",
]
pymodbus-1.3.2/pymodbus/server/sync.py 0000644 0001750 0001750 00000050034 13150360615 016213 0 ustar wmb wmb '''
Implementation of a Threaded Modbus Server
------------------------------------------
'''
from binascii import b2a_hex
import serial
import socket
import traceback
from pymodbus.constants import Defaults
from pymodbus.factory import ServerDecoder
from pymodbus.datastore import ModbusServerContext
from pymodbus.device import ModbusControlBlock
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.transaction import *
from pymodbus.exceptions import NotImplementedException, NoSuchSlaveException
from pymodbus.pdu import ModbusExceptions as merror
from pymodbus.compat import socketserver, byte2int
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Protocol Handlers
#---------------------------------------------------------------------------#
class ModbusBaseRequestHandler(socketserver.BaseRequestHandler):
''' Implements the modbus server protocol
This uses the socketserver.BaseRequestHandler to implement
the client handler.
'''
def setup(self):
''' Callback for when a client connects
'''
_logger.debug("Client Connected [%s:%s]" % self.client_address)
self.running = True
self.framer = self.server.framer(self.server.decoder)
self.server.threads.append(self)
def finish(self):
''' Callback for when a client disconnects
'''
_logger.debug("Client Disconnected [%s:%s]" % self.client_address)
self.server.threads.remove(self)
def execute(self, request):
''' The callback to call with the resulting message
:param request: The decoded request message
'''
try:
context = self.server.context[request.unit_id]
response = request.execute(context)
except NoSuchSlaveException as ex:
_logger.debug("requested slave does not exist: %s" % request.unit_id )
if self.server.ignore_missing_slaves:
return # the client will simply timeout waiting for a response
response = request.doException(merror.GatewayNoResponse)
except Exception as ex:
_logger.debug("Datastore unable to fulfill request: %s; %s", ex, traceback.format_exc() )
response = request.doException(merror.SlaveFailure)
response.transaction_id = request.transaction_id
response.unit_id = request.unit_id
self.send(response)
#---------------------------------------------------------------------------#
# Base class implementations
#---------------------------------------------------------------------------#
def handle(self):
''' Callback when we receive any data
'''
raise NotImplementedException("Method not implemented by derived class")
def send(self, message):
''' Send a request (string) to the network
:param message: The unencoded modbus response
'''
raise NotImplementedException("Method not implemented by derived class")
class ModbusSingleRequestHandler(ModbusBaseRequestHandler):
''' Implements the modbus server protocol
This uses the socketserver.BaseRequestHandler to implement
the client handler for a single client(serial clients)
'''
def handle(self):
''' Callback when we receive any data
'''
while self.running:
try:
data = self.request.recv(1024)
if data:
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug(" ".join([hex(byte2int(x)) for x in data]))
self.framer.processIncomingPacket(data, self.execute)
except Exception as msg:
# since we only have a single socket, we cannot exit
# Clear frame buffer
self.framer.resetFrame()
_logger.error("Socket error occurred %s" % msg)
def send(self, message):
''' Send a request (string) to the network
:param message: The unencoded modbus response
'''
if message.should_respond:
#self.server.control.Counter.BusMessage += 1
pdu = self.framer.buildPacket(message)
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug('send: %s' % b2a_hex(pdu))
return self.request.send(pdu)
class CustomSingleRequestHandler(ModbusSingleRequestHandler):
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
self.running = True
self.setup()
class ModbusConnectedRequestHandler(ModbusBaseRequestHandler):
''' Implements the modbus server protocol
This uses the socketserver.BaseRequestHandler to implement
the client handler for a connected protocol (TCP).
'''
def handle(self):
'''Callback when we receive any data, until self.running becomes not True. Blocks indefinitely
awaiting data. If shutdown is required, then the global socket.settimeout() may be
used, to allow timely checking of self.running. However, since this also affects socket
connects, if there are outgoing socket connections used in the same program, then these will
be prevented, if the specfied timeout is too short. Hence, this is unreliable.
To respond to Modbus...Server.server_close() (which clears each handler's self.running),
derive from this class to provide an alternative handler that awakens from time to time when
no input is available and checks self.running. Use Modbus...Server( handler=... ) keyword
to supply the alternative request handler class.
'''
reset_frame = False
while self.running:
try:
data = self.request.recv(1024)
if not data: self.running = False
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug(' '.join([hex(byte2int(x)) for x in data]))
# if not self.server.control.ListenOnly:
self.framer.processIncomingPacket(data, self.execute)
except socket.timeout as msg:
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug("Socket timeout occurred %s", msg)
reset_frame = True
except socket.error as msg:
_logger.error("Socket error occurred %s" % msg)
self.running = False
except:
_logger.error("Socket exception occurred %s" % traceback.format_exc() )
self.running = False
reset_frame = True
finally:
if reset_frame:
self.framer.resetFrame()
reset_frame = False
def send(self, message):
''' Send a request (string) to the network
:param message: The unencoded modbus response
'''
if message.should_respond:
#self.server.control.Counter.BusMessage += 1
pdu = self.framer.buildPacket(message)
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug('send: %s' % b2a_hex(pdu))
return self.request.send(pdu)
class ModbusDisconnectedRequestHandler(ModbusBaseRequestHandler):
''' Implements the modbus server protocol
This uses the socketserver.BaseRequestHandler to implement
the client handler for a disconnected protocol (UDP). The
only difference is that we have to specify who to send the
resulting packet data to.
'''
def handle(self):
''' Callback when we receive any data
'''
reset_frame = False
while self.running:
try:
data, self.request = self.request
if not data:
self.running = False
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug(' '.join([hex(byte2int(x)) for x in data]))
# if not self.server.control.ListenOnly:
self.framer.processIncomingPacket(data, self.execute)
except socket.timeout: pass
except socket.error as msg:
_logger.error("Socket error occurred %s" % msg)
self.running = False
reset_frame = True
except Exception as msg:
_logger.error(msg)
self.running = False
reset_frame = True
finally:
if reset_frame:
self.framer.resetFrame()
reset_frame = False
def send(self, message):
''' Send a request (string) to the network
:param message: The unencoded modbus response
'''
if message.should_respond:
#self.server.control.Counter.BusMessage += 1
pdu = self.framer.buildPacket(message)
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug('send: %s' % b2a_hex(pdu))
return self.request.sendto(pdu, self.client_address)
#---------------------------------------------------------------------------#
# Server Implementations
#---------------------------------------------------------------------------#
class ModbusTcpServer(socketserver.ThreadingTCPServer):
'''
A modbus threaded tcp socket server
We inherit and overload the socket server so that we
can control the client threads as well as have a single
server context instance.
'''
def __init__(self, context, framer=None, identity=None, address=None, handler=None, **kwargs):
''' Overloaded initializer for the socket server
If the identify structure is not passed in, the ModbusControlBlock
uses its own empty structure.
:param context: The ModbusServerContext datastore
:param framer: The framer strategy to use
:param identity: An optional identify structure
:param address: An optional (interface, port) to bind to.
:param handler: A handler for each client session; default is ModbusConnectedRequestHandler
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
self.threads = []
self.decoder = ServerDecoder()
self.framer = framer or ModbusSocketFramer
self.context = context or ModbusServerContext()
self.control = ModbusControlBlock()
self.address = address or ("", Defaults.Port)
self.ignore_missing_slaves = kwargs.get('ignore_missing_slaves', Defaults.IgnoreMissingSlaves)
if isinstance(identity, ModbusDeviceIdentification):
self.control.Identity.update(identity)
socketserver.ThreadingTCPServer.__init__(self,
self.address, ModbusConnectedRequestHandler)
def process_request(self, request, client):
''' Callback for connecting a new client thread
:param request: The request to handle
:param client: The address of the client
'''
_logger.debug("Started thread to serve client at " + str(client))
socketserver.ThreadingTCPServer.process_request(self, request, client)
def shutdown(self):
''' Stops the serve_forever loop.
Overridden to signal handlers to stop.
'''
for thread in self.threads:
thread.running = False
socketserver.ThreadingTCPServer.shutdown(self)
def server_close(self):
''' Callback for stopping the running server
'''
_logger.debug("Modbus server stopped")
self.socket.close()
for thread in self.threads:
thread.running = False
class ModbusUdpServer(socketserver.ThreadingUDPServer):
'''
A modbus threaded udp socket server
We inherit and overload the socket server so that we
can control the client threads as well as have a single
server context instance.
'''
def __init__(self, context, framer=None, identity=None, address=None, handler=None, **kwargs):
''' Overloaded initializer for the socket server
If the identify structure is not passed in, the ModbusControlBlock
uses its own empty structure.
:param context: The ModbusServerContext datastore
:param framer: The framer strategy to use
:param identity: An optional identify structure
:param address: An optional (interface, port) to bind to.
:param handler: A handler for each client session; default is ModbusDisonnectedRequestHandler
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
self.threads = []
self.decoder = ServerDecoder()
self.framer = framer or ModbusSocketFramer
self.context = context or ModbusServerContext()
self.control = ModbusControlBlock()
self.address = address or ("", Defaults.Port)
self.ignore_missing_slaves = kwargs.get('ignore_missing_slaves', Defaults.IgnoreMissingSlaves)
if isinstance(identity, ModbusDeviceIdentification):
self.control.Identity.update(identity)
socketserver.ThreadingUDPServer.__init__(self,
self.address, ModbusDisconnectedRequestHandler)
def process_request(self, request, client):
''' Callback for connecting a new client thread
:param request: The request to handle
:param client: The address of the client
'''
packet, socket = request # TODO I might have to rewrite
_logger.debug("Started thread to serve client at " + str(client))
socketserver.ThreadingUDPServer.process_request(self, request, client)
def server_close(self):
''' Callback for stopping the running server
'''
_logger.debug("Modbus server stopped")
self.socket.close()
for thread in self.threads:
thread.running = False
class ModbusSerialServer(object):
'''
A modbus threaded serial socket server
We inherit and overload the socket server so that we
can control the client threads as well as have a single
server context instance.
'''
handler = None
def __init__(self, context, framer=None, identity=None, **kwargs):
''' Overloaded initializer for the socket server
If the identify structure is not passed in, the ModbusControlBlock
uses its own empty structure.
:param context: The ModbusServerContext datastore
:param framer: The framer strategy to use
:param identity: An optional identify structure
:param port: The serial port to attach to
:param stopbits: The number of stop bits to use
:param bytesize: The bytesize of the serial messages
:param parity: Which kind of parity to use
:param baudrate: The baud rate to use for the serial device
:param timeout: The timeout to use for the serial device
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
self.threads = []
self.decoder = ServerDecoder()
self.framer = framer or ModbusAsciiFramer
self.context = context or ModbusServerContext()
self.control = ModbusControlBlock()
if isinstance(identity, ModbusDeviceIdentification):
self.control.Identity.update(identity)
self.device = kwargs.get('port', 0)
self.stopbits = kwargs.get('stopbits', Defaults.Stopbits)
self.bytesize = kwargs.get('bytesize', Defaults.Bytesize)
self.parity = kwargs.get('parity', Defaults.Parity)
self.baudrate = kwargs.get('baudrate', Defaults.Baudrate)
self.timeout = kwargs.get('timeout', Defaults.Timeout)
self.ignore_missing_slaves = kwargs.get('ignore_missing_slaves', Defaults.IgnoreMissingSlaves)
self.socket = None
if self._connect():
self.is_running = True
self._build_handler()
def _connect(self):
''' Connect to the serial server
:returns: True if connection succeeded, False otherwise
'''
if self.socket: return True
try:
self.socket = serial.Serial(port=self.device, timeout=self.timeout,
bytesize=self.bytesize, stopbits=self.stopbits,
baudrate=self.baudrate, parity=self.parity)
except serial.SerialException as msg:
_logger.error(msg)
return self.socket != None
def _build_handler(self):
''' A helper method to create and monkeypatch
a serial handler.
:returns: A patched handler
'''
request = self.socket
request.send = request.write
request.recv = request.read
self.handler = CustomSingleRequestHandler(request,
(self.device, self.device),
self)
def serve_forever(self):
''' Callback for connecting a new client thread
:param request: The request to handle
:param client: The address of the client
'''
if self._connect():
_logger.debug("Started thread to serve client")
if not self.handler:
self._build_handler()
while self.is_running:
self.handler.handle()
else:
_logger.error("Error opening serial port , Unable to start server!!")
def server_close(self):
''' Callback for stopping the running server
'''
_logger.debug("Modbus server stopped")
self.is_running = False
self.handler.finish()
self.handler.running = False
self.handler = None
self.socket.close()
#---------------------------------------------------------------------------#
# Creation Factories
#---------------------------------------------------------------------------#
def StartTcpServer(context=None, identity=None, address=None, **kwargs):
''' A factory to start and run a tcp modbus server
:param context: The ModbusServerContext datastore
:param identity: An optional identify structure
:param address: An optional (interface, port) to bind to.
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
framer = ModbusSocketFramer
server = ModbusTcpServer(context, framer, identity, address, **kwargs)
server.serve_forever()
def StartUdpServer(context=None, identity=None, address=None, **kwargs):
''' A factory to start and run a udp modbus server
:param context: The ModbusServerContext datastore
:param identity: An optional identify structure
:param address: An optional (interface, port) to bind to.
:param framer: The framer to operate with (default ModbusSocketFramer)
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
framer = kwargs.pop('framer', ModbusSocketFramer)
server = ModbusUdpServer(context, framer, identity, address, **kwargs)
server.serve_forever()
def StartSerialServer(context=None, identity=None, **kwargs):
''' A factory to start and run a serial modbus server
:param context: The ModbusServerContext datastore
:param identity: An optional identify structure
:param framer: The framer to operate with (default ModbusAsciiFramer)
:param port: The serial port to attach to
:param stopbits: The number of stop bits to use
:param bytesize: The bytesize of the serial messages
:param parity: Which kind of parity to use
:param baudrate: The baud rate to use for the serial device
:param timeout: The timeout to use for the serial device
:param ignore_missing_slaves: True to not send errors on a request to a missing slave
'''
framer = kwargs.pop('framer', ModbusAsciiFramer)
server = ModbusSerialServer(context, framer, identity, **kwargs)
server.serve_forever()
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"StartTcpServer", "StartUdpServer", "StartSerialServer"
]
pymodbus-1.3.2/pymodbus/server/__init__.py 0000644 0001750 0001750 00000000010 13150360615 016763 0 ustar wmb wmb '''
'''
pymodbus-1.3.2/pymodbus/events.py 0000644 0001750 0001750 00000014356 13150360615 015244 0 ustar wmb wmb '''
Modbus Remote Events
------------------------------------------------------------
An event byte returned by the Get Communications Event Log function
can be any one of four types. The type is defined by bit 7
(the high-order bit) in each byte. It may be further defined by bit 6.
'''
from pymodbus.exceptions import NotImplementedException
from pymodbus.exceptions import ParameterException
from pymodbus.utilities import pack_bitstring, unpack_bitstring
class ModbusEvent(object):
def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
raise NotImplementedException()
def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
raise NotImplementedException()
class RemoteReceiveEvent(ModbusEvent):
''' Remote device MODBUS Receive Event
The remote device stores this type of event byte when a query message
is received. It is stored before the remote device processes the message.
This event is defined by bit 7 set to logic '1'. The other bits will be
set to a logic '1' if the corresponding condition is TRUE. The bit layout
is::
Bit Contents
----------------------------------
0 Not Used
2 Not Used
3 Not Used
4 Character Overrun
5 Currently in Listen Only Mode
6 Broadcast Receive
7 1
'''
def __init__(self, **kwargs):
''' Initialize a new event instance
'''
self.overrun = kwargs.get('overrun', False)
self.listen = kwargs.get('listen', False)
self.broadcast = kwargs.get('broadcast', False)
def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
bits = [False] * 3
bits += [self.overrun, self.listen, self.broadcast, True]
packet = pack_bitstring(bits)
return packet
def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
bits = unpack_bitstring(event)
self.overrun = bits[4]
self.listen = bits[5]
self.broadcast = bits[6]
class RemoteSendEvent(ModbusEvent):
''' Remote device MODBUS Send Event
The remote device stores this type of event byte when it finishes
processing a request message. It is stored if the remote device
returned a normal or exception response, or no response.
This event is defined by bit 7 set to a logic '0', with bit 6 set to a '1'.
The other bits will be set to a logic '1' if the corresponding
condition is TRUE. The bit layout is::
Bit Contents
-----------------------------------------------------------
0 Read Exception Sent (Exception Codes 1-3)
1 Slave Abort Exception Sent (Exception Code 4)
2 Slave Busy Exception Sent (Exception Codes 5-6)
3 Slave Program NAK Exception Sent (Exception Code 7)
4 Write Timeout Error Occurred
5 Currently in Listen Only Mode
6 1
7 0
'''
def __init__(self, **kwargs):
''' Initialize a new event instance
'''
self.read = kwargs.get('read', False)
self.slave_abort = kwargs.get('slave_abort', False)
self.slave_busy = kwargs.get('slave_busy', False)
self.slave_nak = kwargs.get('slave_nak', False)
self.write_timeout = kwargs.get('write_timeout', False)
self.listen = kwargs.get('listen', False)
def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
bits = [self.read, self.slave_abort, self.slave_busy,
self.slave_nak, self.write_timeout, self.listen]
bits += [True, False]
packet = pack_bitstring(bits)
return packet
def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
# todo fix the start byte count
bits = unpack_bitstring(event)
self.read = bits[0]
self.slave_abort = bits[1]
self.slave_busy = bits[2]
self.slave_nak = bits[3]
self.write_timeout = bits[4]
self.listen = bits[5]
class EnteredListenModeEvent(ModbusEvent):
''' Remote device Entered Listen Only Mode
The remote device stores this type of event byte when it enters
the Listen Only Mode. The event is defined by a content of 04 hex.
'''
value = 0x04
__encoded = b'\x04'
def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
return self.__encoded
def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
if event != self.__encoded:
raise ParameterException('Invalid decoded value')
class CommunicationRestartEvent(ModbusEvent):
''' Remote device Initiated Communication Restart
The remote device stores this type of event byte when its communications
port is restarted. The remote device can be restarted by the Diagnostics
function (code 08), with sub-function Restart Communications Option
(code 00 01).
That function also places the remote device into a 'Continue on Error'
or 'Stop on Error' mode. If the remote device is placed into 'Continue on
Error' mode, the event byte is added to the existing event log. If the
remote device is placed into 'Stop on Error' mode, the byte is added to
the log and the rest of the log is cleared to zeros.
The event is defined by a content of zero.
'''
value = 0x00
__encoded = b'\x00'
def encode(self):
''' Encodes the status bits to an event message
:returns: The encoded event message
'''
return self.__encoded
def decode(self, event):
''' Decodes the event message to its status bits
:param event: The event to decode
'''
if event != self.__encoded:
raise ParameterException('Invalid decoded value')
pymodbus-1.3.2/pymodbus/transaction.py 0000644 0001750 0001750 00000115762 13150360615 016270 0 ustar wmb wmb '''
Collection of transaction based abstractions
'''
import sys
import struct
import socket
from binascii import b2a_hex, a2b_hex
from pymodbus.exceptions import ModbusIOException, NotImplementedException
from pymodbus.exceptions import InvalidMessageRecievedException
from pymodbus.constants import Defaults
from pymodbus.interfaces import IModbusFramer
from pymodbus.utilities import checkCRC, computeCRC
from pymodbus.utilities import checkLRC, computeLRC
from pymodbus.compat import iterkeys, imap, byte2int
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# The Global Transaction Manager
#---------------------------------------------------------------------------#
class ModbusTransactionManager(object):
''' Impelements a transaction for a manager
The transaction protocol can be represented by the following pseudo code::
count = 0
do
result = send(message)
if (timeout or result == bad)
count++
else break
while (count < 3)
This module helps to abstract this away from the framer and protocol.
'''
def __init__(self, client, **kwargs):
''' Initializes an instance of the ModbusTransactionManager
:param client: The client socket wrapper
:param retry_on_empty: Should the client retry on empty
:param retries: The number of retries to allow
'''
self.tid = Defaults.TransactionId
self.client = client
self.retry_on_empty = kwargs.get('retry_on_empty', Defaults.RetryOnEmpty)
self.retries = kwargs.get('retries', Defaults.Retries)
if client:
self._set_adu_size()
def _set_adu_size(self):
# base ADU size of modbus frame in bytes
if isinstance(self.client.framer, ModbusSocketFramer):
self.base_adu_size = 7 # tid(2), pid(2), length(2), uid(1)
elif isinstance(self.client.framer, ModbusRtuFramer):
self.base_adu_size = 3 # address(1), CRC(2)
elif isinstance(self.client.framer, ModbusAsciiFramer):
self.base_adu_size = 7 # start(1)+ Address(2), LRC(2) + end(2)
elif isinstance(self.client.framer, ModbusBinaryFramer):
self.base_adu_size = 3 #, Address(1), CRC(2)
else:
self.base_adu_size = -1
def _calculate_response_length(self, expected_pdu_size):
if self.base_adu_size == -1:
return None
else:
return self.base_adu_size + expected_pdu_size
def _calculate_exception_length(self):
''' Returns the length of the Modbus Exception Response according to
the type of Framer.
'''
if isinstance(self.client.framer, ModbusSocketFramer):
return self.base_adu_size + 2 # Fcode(1), ExcecptionCode(1)
elif isinstance(self.client.framer, ModbusAsciiFramer):
return self.base_adu_size + 4 # Fcode(2), ExcecptionCode(2)
elif isinstance(self.client.framer, (ModbusRtuFramer, ModbusBinaryFramer)):
return self.base_adu_size + 2 # Fcode(1), ExcecptionCode(1)
return None
def _check_response(self, response):
''' Checks if the response is a Modbus Exception.
'''
if isinstance(self.client.framer, ModbusSocketFramer):
if len(response) >= 8 and byte2int(response[7]) > 128:
return False
elif isinstance(self.client.framer, ModbusAsciiFramer):
if len(response) >= 5 and int(response[3:5], 16) > 128:
return False
elif isinstance(self.client.framer, (ModbusRtuFramer,
ModbusBinaryFramer)):
if len(response) >= 2 and byte2int(response[1]) > 128:
return False
return True
def execute(self, request):
''' Starts the producer to send the next request to
consumer.write(Frame(request))
'''
retries = self.retries
request.transaction_id = self.getNextTID()
_logger.debug("Running transaction %d" % request.transaction_id)
self.client.framer.resetFrame()
expected_response_length = None
if hasattr(request, "get_response_pdu_size"):
response_pdu_size = request.get_response_pdu_size()
if isinstance(self.client.framer, ModbusAsciiFramer):
response_pdu_size = response_pdu_size * 2
if response_pdu_size:
expected_response_length = self._calculate_response_length(response_pdu_size)
while retries > 0:
try:
last_exception = None
self.client.connect()
packet = self.client.framer.buildPacket(request)
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug("send: " + " ".join([hex(byte2int(x)) for x in packet]))
self._send(packet)
# exception = False
result = self._recv(expected_response_length or 1024)
if not result and self.retry_on_empty:
retries -= 1
continue
if _logger.isEnabledFor(logging.DEBUG):
_logger.debug("recv: " + " ".join([hex(byte2int(x)) for x in result]))
self.client.framer.processIncomingPacket(result, self.addTransaction)
break
except (socket.error, ModbusIOException, InvalidMessageRecievedException) as msg:
self.client.close()
_logger.debug("Transaction failed. (%s) " % msg)
retries -= 1
last_exception = msg
response = self.getTransaction(request.transaction_id)
if not response:
if len(self.transactions):
response = self.getTransaction(tid=0)
else:
last_exception = last_exception or ("No Response "
"received from the remote unit")
response = ModbusIOException(last_exception)
return response
def _send(self, packet):
return self.client._send(packet)
def _recv(self, expected_response_length):
retries = self.retries
exception = False
while retries:
result = self.client._recv(expected_response_length or 1024)
while result and expected_response_length and len(
result) < expected_response_length:
if not exception and not self._check_response(result):
exception = True
expected_response_length = self._calculate_exception_length()
continue
if isinstance(self.client.framer, ModbusSocketFramer):
break
r = self.client._recv(expected_response_length - len(result))
if not r:
# If no response being recived there is no point in conitnuing
break
result += r
if result:
break
retries -= 1
return result
def addTransaction(self, request, tid=None):
''' Adds a transaction to the handler
This holds the requets in case it needs to be resent.
After being sent, the request is removed.
:param request: The request to hold on to
:param tid: The overloaded transaction id to use
'''
raise NotImplementedException("addTransaction")
def getTransaction(self, tid):
''' Returns a transaction matching the referenced tid
If the transaction does not exist, None is returned
:param tid: The transaction to retrieve
'''
raise NotImplementedException("getTransaction")
def delTransaction(self, tid):
''' Removes a transaction matching the referenced tid
:param tid: The transaction to remove
'''
raise NotImplementedException("delTransaction")
def getNextTID(self):
''' Retrieve the next unique transaction identifier
This handles incrementing the identifier after
retrieval
:returns: The next unique transaction identifier
'''
self.tid = (self.tid + 1) & 0xffff
return self.tid
def reset(self):
''' Resets the transaction identifier '''
self.tid = Defaults.TransactionId
self.transactions = type(self.transactions)()
class DictTransactionManager(ModbusTransactionManager):
''' Impelements a transaction for a manager where the
results are keyed based on the supplied transaction id.
'''
def __init__(self, client, **kwargs):
''' Initializes an instance of the ModbusTransactionManager
:param client: The client socket wrapper
'''
self.transactions = {}
super(DictTransactionManager, self).__init__(client, **kwargs)
def __iter__(self):
''' Iterater over the current managed transactions
:returns: An iterator of the managed transactions
'''
return iterkeys(self.transactions)
def addTransaction(self, request, tid=None):
''' Adds a transaction to the handler
This holds the requets in case it needs to be resent.
After being sent, the request is removed.
:param request: The request to hold on to
:param tid: The overloaded transaction id to use
'''
tid = tid if tid != None else request.transaction_id
_logger.debug("adding transaction %d" % tid)
self.transactions[tid] = request
def getTransaction(self, tid):
''' Returns a transaction matching the referenced tid
If the transaction does not exist, None is returned
:param tid: The transaction to retrieve
'''
_logger.debug("getting transaction %d" % tid)
return self.transactions.pop(tid, None)
def delTransaction(self, tid):
''' Removes a transaction matching the referenced tid
:param tid: The transaction to remove
'''
_logger.debug("deleting transaction %d" % tid)
self.transactions.pop(tid, None)
class FifoTransactionManager(ModbusTransactionManager):
''' Impelements a transaction for a manager where the
results are returned in a FIFO manner.
'''
def __init__(self, client, **kwargs):
''' Initializes an instance of the ModbusTransactionManager
:param client: The client socket wrapper
'''
super(FifoTransactionManager, self).__init__(client, **kwargs)
self.transactions = []
def __iter__(self):
''' Iterater over the current managed transactions
:returns: An iterator of the managed transactions
'''
return iter(self.transactions)
def addTransaction(self, request, tid=None):
''' Adds a transaction to the handler
This holds the requets in case it needs to be resent.
After being sent, the request is removed.
:param request: The request to hold on to
:param tid: The overloaded transaction id to use
'''
tid = tid if tid != None else request.transaction_id
_logger.debug("adding transaction %d" % tid)
self.transactions.append(request)
def getTransaction(self, tid):
''' Returns a transaction matching the referenced tid
If the transaction does not exist, None is returned
:param tid: The transaction to retrieve
'''
_logger.debug("getting transaction %s" % str(tid))
return self.transactions.pop(0) if self.transactions else None
def delTransaction(self, tid):
''' Removes a transaction matching the referenced tid
:param tid: The transaction to remove
'''
_logger.debug("deleting transaction %d" % tid)
if self.transactions: self.transactions.pop(0)
#---------------------------------------------------------------------------#
# Modbus TCP Message
#---------------------------------------------------------------------------#
class ModbusSocketFramer(IModbusFramer):
''' Modbus Socket Frame controller
Before each modbus TCP message is an MBAP header which is used as a
message frame. It allows us to easily separate messages as follows::
[ MBAP Header ] [ Function Code] [ Data ]
[ tid ][ pid ][ length ][ uid ]
2b 2b 2b 1b 1b Nb
while len(message) > 0:
tid, pid, length`, uid = struct.unpack(">HHHB", message)
request = message[0:7 + length - 1`]
message = [7 + length - 1:]
* length = uid + function code + data
* The -1 is to account for the uid byte
'''
def __init__(self, decoder):
''' Initializes a new instance of the framer
:param decoder: The decoder factory implementation to use
'''
self.__buffer = b''
self.__header = {'tid':0, 'pid':0, 'len':0, 'uid':0}
self.__hsize = 0x07
self.decoder = decoder
#-----------------------------------------------------------------------#
# Private Helper Functions
#-----------------------------------------------------------------------#
def checkFrame(self):
'''
Check and decode the next frame Return true if we were successful
'''
if len(self.__buffer) > self.__hsize:
self.__header['tid'], self.__header['pid'], \
self.__header['len'], self.__header['uid'] = struct.unpack(
'>HHHB', self.__buffer[0:self.__hsize])
# someone sent us an error? ignore it
if self.__header['len'] < 2:
self.advanceFrame()
# we have at least a complete message, continue
elif len(self.__buffer) - self.__hsize + 1 >= self.__header['len']:
return True
# we don't have enough of a message yet, wait
return False
def advanceFrame(self):
''' Skip over the current framed message
This allows us to skip over the current message after we have processed
it or determined that it contains an error. It also has to reset the
current frame header handle
'''
length = self.__hsize + self.__header['len'] - 1
self.__buffer = self.__buffer[length:]
self.__header = {'tid':0, 'pid':0, 'len':0, 'uid':0}
def isFrameReady(self):
''' Check if we should continue decode logic
This is meant to be used in a while loop in the decoding phase to let
the decoder factory know that there is still data in the buffer.
:returns: True if ready, False otherwise
'''
return len(self.__buffer) > self.__hsize
def addToFrame(self, message):
''' Adds new packet data to the current frame buffer
:param message: The most recent packet
'''
self.__buffer += message
def getFrame(self):
''' Return the next frame from the buffered data
:returns: The next full frame buffer
'''
length = self.__hsize + self.__header['len'] - 1
return self.__buffer[self.__hsize:length]
def populateResult(self, result):
'''
Populates the modbus result with the transport specific header
information (pid, tid, uid, checksum, etc)
:param result: The response packet
'''
result.transaction_id = self.__header['tid']
result.protocol_id = self.__header['pid']
result.unit_id = self.__header['uid']
#-----------------------------------------------------------------------#
# Public Member Functions
#-----------------------------------------------------------------------#
def processIncomingPacket(self, data, callback):
''' The new packet processing pattern
This takes in a new request packet, adds it to the current
packet stream, and performs framing on it. That is, checks
for complete messages, and once found, will process all that
exist. This handles the case when we read N + 1 or 1 / N
messages at a time instead of 1.
The processed and decoded messages are pushed to the callback
function to process and send.
:param data: The new packet data
:param callback: The function to send results to
'''
_logger.debug(' '.join([hex(byte2int(x)) for x in data]))
self.addToFrame(data)
while True:
if self.isFrameReady():
if self.checkFrame():
self._process(callback)
else: self.resetFrame()
else:
if len(self.__buffer):
# Possible error ???
if self.__header['len'] < 2:
self._process(callback, error=True)
break
def _process(self, callback, error=False):
"""
Process incoming packets irrespective error condition
"""
data = self.getRawFrame() if error else self.getFrame()
result = self.decoder.decode(data)
if result is None:
raise ModbusIOException("Unable to decode request")
elif error and result.function_code < 0x80:
raise InvalidMessageRecievedException(result)
else:
self.populateResult(result)
self.advanceFrame()
callback(result) # defer or push to a thread?
def resetFrame(self):
''' Reset the entire message frame.
This allows us to skip ovver errors that may be in the stream.
It is hard to know if we are simply out of sync or if there is
an error in the stream as we have no way to check the start or
end of the message (python just doesn't have the resolution to
check for millisecond delays).
'''
self.__buffer = b''
self.__header = {}
def getRawFrame(self):
"""
Returns the complete buffer
"""
return self.__buffer
def buildPacket(self, message):
''' Creates a ready to send modbus packet
:param message: The populated request/response to send
'''
data = message.encode()
packet = struct.pack('>HHHBB',
message.transaction_id,
message.protocol_id,
len(data) + 2,
message.unit_id,
message.function_code) + data
return packet
#---------------------------------------------------------------------------#
# Modbus RTU Message
#---------------------------------------------------------------------------#
class ModbusRtuFramer(IModbusFramer):
'''
Modbus RTU Frame controller::
[ Start Wait ] [Address ][ Function Code] [ Data ][ CRC ][ End Wait ]
3.5 chars 1b 1b Nb 2b 3.5 chars
Wait refers to the amount of time required to transmist at least x many
characters. In this case it is 3.5 characters. Also, if we recieve a
wait of 1.5 characters at any point, we must trigger an error message.
Also, it appears as though this message is little endian. The logic is
simplified as the following::
block-on-read:
read until 3.5 delay
check for errors
decode
The following table is a listing of the baud wait times for the specified
baud rates::
------------------------------------------------------------------
Baud 1.5c (18 bits) 3.5c (38 bits)
------------------------------------------------------------------
1200 13333.3 us 31666.7 us
4800 3333.3 us 7916.7 us
9600 1666.7 us 3958.3 us
19200 833.3 us 1979.2 us
38400 416.7 us 989.6 us
------------------------------------------------------------------
1 Byte = start + 8 bits + parity + stop = 11 bits
(1/Baud)(bits) = delay seconds
'''
def __init__(self, decoder):
''' Initializes a new instance of the framer
:param decoder: The decoder factory implementation to use
'''
self.__buffer = b''
self.__header = {}
self.__hsize = 0x01
self.__end = b'\x0d\x0a'
self.__min_frame_size = 4
self.decoder = decoder
#-----------------------------------------------------------------------#
# Private Helper Functions
#-----------------------------------------------------------------------#
def checkFrame(self):
'''
Check if the next frame is available. Return True if we were
successful.
'''
try:
self.populateHeader()
frame_size = self.__header['len']
data = self.__buffer[:frame_size - 2]
crc = self.__buffer[frame_size - 2:frame_size]
crc_val = (byte2int(crc[0]) << 8) + byte2int(crc[1])
return checkCRC(data, crc_val)
except (IndexError, KeyError):
return False
def advanceFrame(self):
''' Skip over the current framed message
This allows us to skip over the current message after we have processed
it or determined that it contains an error. It also has to reset the
current frame header handle
'''
try:
self.__buffer = self.__buffer[self.__header['len']:]
except KeyError:
# Error response, no header len found
self.resetFrame()
self.__header = {}
def resetFrame(self):
''' Reset the entire message frame.
This allows us to skip ovver errors that may be in the stream.
It is hard to know if we are simply out of sync or if there is
an error in the stream as we have no way to check the start or
end of the message (python just doesn't have the resolution to
check for millisecond delays).
'''
self.__buffer = b''
self.__header = {}
def isFrameReady(self):
''' Check if we should continue decode logic
This is meant to be used in a while loop in the decoding phase to let
the decoder know that there is still data in the buffer.
:returns: True if ready, False otherwise
'''
return len(self.__buffer) > self.__hsize
def populateHeader(self):
''' Try to set the headers `uid`, `len` and `crc`.
This method examines `self.__buffer` and writes meta
information into `self.__header`. It calculates only the
values for headers that are not already in the dictionary.
Beware that this method will raise an IndexError if
`self.__buffer` is not yet long enough.
'''
self.__header['uid'] = byte2int(self.__buffer[0])
func_code = byte2int(self.__buffer[1])
pdu_class = self.decoder.lookupPduClass(func_code)
size = pdu_class.calculateRtuFrameSize(self.__buffer)
self.__header['len'] = size
self.__header['crc'] = self.__buffer[size - 2:size]
def addToFrame(self, message):
'''
This should be used before the decoding while loop to add the received
data to the buffer handle.
:param message: The most recent packet
'''
self.__buffer += message
def getFrame(self):
''' Get the next frame from the buffer
:returns: The frame data or ''
'''
start = self.__hsize
end = self.__header['len'] - 2
buffer = self.__buffer[start:end]
if end > 0: return buffer
return ''
def populateResult(self, result):
''' Populates the modbus result header
The serial packets do not have any header information
that is copied.
:param result: The response packet
'''
result.unit_id = self.__header['uid']
#-----------------------------------------------------------------------#
# Public Member Functions
#-----------------------------------------------------------------------#
def processIncomingPacket(self, data, callback):
''' The new packet processing pattern
This takes in a new request packet, adds it to the current
packet stream, and performs framing on it. That is, checks
for complete messages, and once found, will process all that
exist. This handles the case when we read N + 1 or 1 / N
messages at a time instead of 1.
The processed and decoded messages are pushed to the callback
function to process and send.
:param data: The new packet data
:param callback: The function to send results to
'''
self.addToFrame(data)
while True:
if self.isFrameReady():
if self.checkFrame():
self._process(callback)
else:
# Could be an error response
if len(self.__buffer):
# Possible error ???
self._process(callback, error=True)
else:
if len(self.__buffer):
# Possible error ???
if self.__header.get('len', 0) < 2:
self._process(callback, error=True)
break
def buildPacket(self, message):
''' Creates a ready to send modbus packet
:param message: The populated request/response to send
'''
data = message.encode()
packet = struct.pack('>BB',
message.unit_id,
message.function_code) + data
packet += struct.pack(">H", computeCRC(packet))
return packet
def _process(self, callback, error=False):
"""
Process incoming packets irrespective error condition
"""
data = self.getRawFrame() if error else self.getFrame()
result = self.decoder.decode(data)
if result is None:
raise ModbusIOException("Unable to decode request")
elif error and result.function_code < 0x80:
raise InvalidMessageRecievedException(result)
else:
self.populateResult(result)
self.advanceFrame()
callback(result) # defer or push to a thread?
def getRawFrame(self):
"""
Returns the complete buffer
"""
return self.__buffer
#---------------------------------------------------------------------------#
# Modbus ASCII Message
#---------------------------------------------------------------------------#
class ModbusAsciiFramer(IModbusFramer):
'''
Modbus ASCII Frame Controller::
[ Start ][Address ][ Function ][ Data ][ LRC ][ End ]
1c 2c 2c Nc 2c 2c
* data can be 0 - 2x252 chars
* end is '\\r\\n' (Carriage return line feed), however the line feed
character can be changed via a special command
* start is ':'
This framer is used for serial transmission. Unlike the RTU protocol,
the data in this framer is transferred in plain text ascii.
'''
def __init__(self, decoder):
''' Initializes a new instance of the framer
:param decoder: The decoder implementation to use
'''
self.__buffer = b''
self.__header = {'lrc':'0000', 'len':0, 'uid':0x00}
self.__hsize = 0x02
self.__start = b':'
self.__end = b"\r\n"
self.decoder = decoder
#-----------------------------------------------------------------------#
# Private Helper Functions
#-----------------------------------------------------------------------#
def checkFrame(self):
''' Check and decode the next frame
:returns: True if we successful, False otherwise
'''
start = self.__buffer.find(self.__start)
if start == -1: return False
if start > 0 : # go ahead and skip old bad data
self.__buffer = self.__buffer[start:]
start = 0
end = self.__buffer.find(self.__end)
if (end != -1):
self.__header['len'] = end
self.__header['uid'] = int(self.__buffer[1:3], 16)
self.__header['lrc'] = int(self.__buffer[end - 2:end], 16)
data = a2b_hex(self.__buffer[start + 1:end - 2])
return checkLRC(data, self.__header['lrc'])
return False
def advanceFrame(self):
''' Skip over the current framed message
This allows us to skip over the current message after we have processed
it or determined that it contains an error. It also has to reset the
current frame header handle
'''
self.__buffer = self.__buffer[self.__header['len'] + 2:]
self.__header = {'lrc':'0000', 'len':0, 'uid':0x00}
def isFrameReady(self):
''' Check if we should continue decode logic
This is meant to be used in a while loop in the decoding phase to let
the decoder know that there is still data in the buffer.
:returns: True if ready, False otherwise
'''
return len(self.__buffer) > 1
def addToFrame(self, message):
''' Add the next message to the frame buffer
This should be used before the decoding while loop to add the received
data to the buffer handle.
:param message: The most recent packet
'''
self.__buffer += message
def getFrame(self):
''' Get the next frame from the buffer
:returns: The frame data or ''
'''
start = self.__hsize + 1
end = self.__header['len'] - 2
buffer = self.__buffer[start:end]
if end > 0: return a2b_hex(buffer)
return b''
def resetFrame(self):
''' Reset the entire message frame.
This allows us to skip ovver errors that may be in the stream.
It is hard to know if we are simply out of sync or if there is
an error in the stream as we have no way to check the start or
end of the message (python just doesn't have the resolution to
check for millisecond delays).
'''
self.__buffer = b''
self.__header = {'lrc':'0000', 'len':0, 'uid':0x00}
def populateResult(self, result):
''' Populates the modbus result header
The serial packets do not have any header information
that is copied.
:param result: The response packet
'''
result.unit_id = self.__header['uid']
#-----------------------------------------------------------------------#
# Public Member Functions
#-----------------------------------------------------------------------#
def processIncomingPacket(self, data, callback):
''' The new packet processing pattern
This takes in a new request packet, adds it to the current
packet stream, and performs framing on it. That is, checks
for complete messages, and once found, will process all that
exist. This handles the case when we read N + 1 or 1 / N
messages at a time instead of 1.
The processed and decoded messages are pushed to the callback
function to process and send.
:param data: The new packet data
:param callback: The function to send results to
'''
self.addToFrame(data)
while self.isFrameReady():
if self.checkFrame():
result = self.decoder.decode(self.getFrame())
if result is None:
raise ModbusIOException("Unable to decode response")
self.populateResult(result)
self.advanceFrame()
callback(result) # defer this
else:
break
def buildPacket(self, message):
''' Creates a ready to send modbus packet
Built off of a modbus request/response
:param message: The request/response to send
:return: The encoded packet
'''
encoded = message.encode()
buffer = struct.pack('>BB', message.unit_id, message.function_code)
checksum = computeLRC(encoded + buffer)
packet = bytearray()
params = (message.unit_id, message.function_code)
packet.extend(self.__start)
packet.extend(('%02x%02x' % params).encode())
packet.extend(b2a_hex(encoded))
packet.extend(('%02x' % checksum).encode())
packet.extend(self.__end)
return bytes(packet).upper()
#---------------------------------------------------------------------------#
# Modbus Binary Message
#---------------------------------------------------------------------------#
class ModbusBinaryFramer(IModbusFramer):
'''
Modbus Binary Frame Controller::
[ Start ][Address ][ Function ][ Data ][ CRC ][ End ]
1b 1b 1b Nb 2b 1b
* data can be 0 - 2x252 chars
* end is '}'
* start is '{'
The idea here is that we implement the RTU protocol, however,
instead of using timing for message delimiting, we use start
and end of message characters (in this case { and }). Basically,
this is a binary framer.
The only case we have to watch out for is when a message contains
the { or } characters. If we encounter these characters, we
simply duplicate them. Hopefully we will not encounter those
characters that often and will save a little bit of bandwitch
without a real-time system.
Protocol defined by jamod.sourceforge.net.
'''
def __init__(self, decoder):
''' Initializes a new instance of the framer
:param decoder: The decoder implementation to use
'''
self.__buffer = b''
self.__header = {'crc':0x0000, 'len':0, 'uid':0x00}
self.__hsize = 0x02
self.__start = b'\x7b' # {
self.__end = b'\x7d' # }
self.__repeat = [b'}'[0], b'{'[0]] # python3 hack
self.decoder = decoder
#-----------------------------------------------------------------------#
# Private Helper Functions
#-----------------------------------------------------------------------#
def checkFrame(self):
''' Check and decode the next frame
:returns: True if we are successful, False otherwise
'''
start = self.__buffer.find(self.__start)
if start == -1: return False
if start > 0 : # go ahead and skip old bad data
self.__buffer = self.__buffer[start:]
end = self.__buffer.find(self.__end)
if (end != -1):
self.__header['len'] = end
self.__header['uid'] = struct.unpack('>B', self.__buffer[1:2])
self.__header['crc'] = struct.unpack('>H', self.__buffer[end - 2:end])[0]
data = self.__buffer[start + 1:end - 2]
return checkCRC(data, self.__header['crc'])
return False
def advanceFrame(self):
''' Skip over the current framed message
This allows us to skip over the current message after we have processed
it or determined that it contains an error. It also has to reset the
current frame header handle
'''
self.__buffer = self.__buffer[self.__header['len'] + 2:]
self.__header = {'crc':0x0000, 'len':0, 'uid':0x00}
def isFrameReady(self):
''' Check if we should continue decode logic
This is meant to be used in a while loop in the decoding phase to let
the decoder know that there is still data in the buffer.
:returns: True if ready, False otherwise
'''
return len(self.__buffer) > 1
def addToFrame(self, message):
''' Add the next message to the frame buffer
This should be used before the decoding while loop to add the received
data to the buffer handle.
:param message: The most recent packet
'''
self.__buffer += message
def getFrame(self):
''' Get the next frame from the buffer
:returns: The frame data or ''
'''
start = self.__hsize + 1
end = self.__header['len'] - 2
buffer = self.__buffer[start:end]
if end > 0: return buffer
return b''
def populateResult(self, result):
''' Populates the modbus result header
The serial packets do not have any header information
that is copied.
:param result: The response packet
'''
result.unit_id = self.__header['uid']
#-----------------------------------------------------------------------#
# Public Member Functions
#-----------------------------------------------------------------------#
def processIncomingPacket(self, data, callback):
''' The new packet processing pattern
This takes in a new request packet, adds it to the current
packet stream, and performs framing on it. That is, checks
for complete messages, and once found, will process all that
exist. This handles the case when we read N + 1 or 1 / N
messages at a time instead of 1.
The processed and decoded messages are pushed to the callback
function to process and send.
:param data: The new packet data
:param callback: The function to send results to
'''
self.addToFrame(data)
while self.isFrameReady():
if self.checkFrame():
result = self.decoder.decode(self.getFrame())
if result is None:
raise ModbusIOException("Unable to decode response")
self.populateResult(result)
self.advanceFrame()
callback(result) # defer or push to a thread?
else:
break
def buildPacket(self, message):
''' Creates a ready to send modbus packet
:param message: The request/response to send
:returns: The encoded packet
'''
data = self._preflight(message.encode())
packet = struct.pack('>BB',
message.unit_id,
message.function_code) + data
packet += struct.pack(">H", computeCRC(packet))
packet = self.__start + packet + self.__end
return packet
def _preflight(self, data):
''' Preflight buffer test
This basically scans the buffer for start and end
tags and if found, escapes them.
:param data: The message to escape
:returns: the escaped packet
'''
array = bytearray()
for d in data:
if d in self.__repeat:
array.append(d)
array.append(d)
return bytes(array)
def resetFrame(self):
''' Reset the entire message frame.
This allows us to skip ovver errors that may be in the stream.
It is hard to know if we are simply out of sync or if there is
an error in the stream as we have no way to check the start or
end of the message (python just doesn't have the resolution to
check for millisecond delays).
'''
self.__buffer = b''
self.__header = {'crc': 0x0000, 'len': 0, 'uid': 0x00}
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"FifoTransactionManager",
"DictTransactionManager",
"ModbusSocketFramer", "ModbusRtuFramer",
"ModbusAsciiFramer", "ModbusBinaryFramer",
]
pymodbus-1.3.2/pymodbus/factory.py 0000644 0001750 0001750 00000022671 13150360615 015406 0 ustar wmb wmb """
Modbus Request/Response Decoder Factories
-------------------------------------------
The following factories make it easy to decode request/response messages.
To add a new request/response pair to be decodeable by the library, simply
add them to the respective function lookup table (order doesn't matter, but
it does help keep things organized).
Regardless of how many functions are added to the lookup, O(1) behavior is
kept as a result of a pre-computed lookup dictionary.
"""
from pymodbus.pdu import IllegalFunctionRequest
from pymodbus.pdu import ExceptionResponse
from pymodbus.pdu import ModbusExceptions as ecode
from pymodbus.interfaces import IModbusDecoder
from pymodbus.exceptions import ModbusException
from pymodbus.bit_read_message import *
from pymodbus.bit_write_message import *
from pymodbus.diag_message import *
from pymodbus.file_message import *
from pymodbus.other_message import *
from pymodbus.mei_message import *
from pymodbus.register_read_message import *
from pymodbus.register_write_message import *
from pymodbus.compat import byte2int
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Server Decoder
#---------------------------------------------------------------------------#
class ServerDecoder(IModbusDecoder):
''' Request Message Factory (Server)
To add more implemented functions, simply add them to the list
'''
__function_table = [
ReadHoldingRegistersRequest,
ReadDiscreteInputsRequest,
ReadInputRegistersRequest,
ReadCoilsRequest,
WriteMultipleCoilsRequest,
WriteMultipleRegistersRequest,
WriteSingleRegisterRequest,
WriteSingleCoilRequest,
ReadWriteMultipleRegistersRequest,
DiagnosticStatusRequest,
ReadExceptionStatusRequest,
GetCommEventCounterRequest,
GetCommEventLogRequest,
ReportSlaveIdRequest,
ReadFileRecordRequest,
WriteFileRecordRequest,
MaskWriteRegisterRequest,
ReadFifoQueueRequest,
ReadDeviceInformationRequest,
]
__sub_function_table = [
ReturnQueryDataRequest,
RestartCommunicationsOptionRequest,
ReturnDiagnosticRegisterRequest,
ChangeAsciiInputDelimiterRequest,
ForceListenOnlyModeRequest,
ClearCountersRequest,
ReturnBusMessageCountRequest,
ReturnBusCommunicationErrorCountRequest,
ReturnBusExceptionErrorCountRequest,
ReturnSlaveMessageCountRequest,
ReturnSlaveNoResponseCountRequest,
ReturnSlaveNAKCountRequest,
ReturnSlaveBusyCountRequest,
ReturnSlaveBusCharacterOverrunCountRequest,
ReturnIopOverrunCountRequest,
ClearOverrunCountRequest,
GetClearModbusPlusRequest,
ReadDeviceInformationRequest,
]
def __init__(self):
''' Initializes the client lookup tables
'''
functions = set(f.function_code for f in self.__function_table)
self.__lookup = dict([(f.function_code, f) for f in self.__function_table])
self.__sub_lookup = dict((f, {}) for f in functions)
for f in self.__sub_function_table:
self.__sub_lookup[f.function_code][f.sub_function_code] = f
def decode(self, message):
''' Wrapper to decode a request packet
:param message: The raw modbus request packet
:return: The decoded modbus message or None if error
'''
try:
return self._helper(message)
except ModbusException as er:
_logger.warning("Unable to decode request %s" % er)
return None
def lookupPduClass(self, function_code):
''' Use `function_code` to determine the class of the PDU.
:param function_code: The function code specified in a frame.
:returns: The class of the PDU that has a matching `function_code`.
'''
return self.__lookup.get(function_code, ExceptionResponse)
def _helper(self, data):
'''
This factory is used to generate the correct request object
from a valid request packet. This decodes from a list of the
currently implemented request types.
:param data: The request packet to decode
:returns: The decoded request or illegal function request object
'''
function_code = byte2int(data[0])
_logger.debug("Factory Request[%d]" % function_code)
request = self.__lookup.get(function_code, lambda: None)()
if not request:
request = IllegalFunctionRequest(function_code)
request.decode(data[1:])
if hasattr(request, 'sub_function_code'):
lookup = self.__sub_lookup.get(request.function_code, {})
subtype = lookup.get(request.sub_function_code, None)
if subtype: request.__class__ = subtype
return request
#---------------------------------------------------------------------------#
# Client Decoder
#---------------------------------------------------------------------------#
class ClientDecoder(IModbusDecoder):
''' Response Message Factory (Client)
To add more implemented functions, simply add them to the list
'''
__function_table = [
ReadHoldingRegistersResponse,
ReadDiscreteInputsResponse,
ReadInputRegistersResponse,
ReadCoilsResponse,
WriteMultipleCoilsResponse,
WriteMultipleRegistersResponse,
WriteSingleRegisterResponse,
WriteSingleCoilResponse,
ReadWriteMultipleRegistersResponse,
DiagnosticStatusResponse,
ReadExceptionStatusResponse,
GetCommEventCounterResponse,
GetCommEventLogResponse,
ReportSlaveIdResponse,
ReadFileRecordResponse,
WriteFileRecordResponse,
MaskWriteRegisterResponse,
ReadFifoQueueResponse,
ReadDeviceInformationResponse,
]
__sub_function_table = [
ReturnQueryDataResponse,
RestartCommunicationsOptionResponse,
ReturnDiagnosticRegisterResponse,
ChangeAsciiInputDelimiterResponse,
ForceListenOnlyModeResponse,
ClearCountersResponse,
ReturnBusMessageCountResponse,
ReturnBusCommunicationErrorCountResponse,
ReturnBusExceptionErrorCountResponse,
ReturnSlaveMessageCountResponse,
ReturnSlaveNoReponseCountResponse,
ReturnSlaveNAKCountResponse,
ReturnSlaveBusyCountResponse,
ReturnSlaveBusCharacterOverrunCountResponse,
ReturnIopOverrunCountResponse,
ClearOverrunCountResponse,
GetClearModbusPlusResponse,
ReadDeviceInformationResponse,
]
def __init__(self):
''' Initializes the client lookup tables
'''
functions = set(f.function_code for f in self.__function_table)
self.__lookup = dict([(f.function_code, f) for f in self.__function_table])
self.__sub_lookup = dict((f, {}) for f in functions)
for f in self.__sub_function_table:
self.__sub_lookup[f.function_code][f.sub_function_code] = f
def lookupPduClass(self, function_code):
''' Use `function_code` to determine the class of the PDU.
:param function_code: The function code specified in a frame.
:returns: The class of the PDU that has a matching `function_code`.
'''
return self.__lookup.get(function_code, ExceptionResponse)
def decode(self, message):
''' Wrapper to decode a response packet
:param message: The raw packet to decode
:return: The decoded modbus message or None if error
'''
try:
return self._helper(message)
except ModbusException as er:
_logger.error("Unable to decode response %s" % er)
return None
def _helper(self, data):
'''
This factory is used to generate the correct response object
from a valid response packet. This decodes from a list of the
currently implemented request types.
:param data: The response packet to decode
:returns: The decoded request or an exception response object
'''
function_code = byte2int(data[0])
_logger.debug("Factory Response[%d]" % function_code)
response = self.__lookup.get(function_code, lambda: None)()
if function_code > 0x80:
code = function_code & 0x7f # strip error portion
response = ExceptionResponse(code, ecode.IllegalFunction)
if not response:
raise ModbusException("Unknown response %d" % function_code)
response.decode(data[1:])
if hasattr(response, 'sub_function_code'):
lookup = self.__sub_lookup.get(response.function_code, {})
subtype = lookup.get(response.sub_function_code, None)
if subtype: response.__class__ = subtype
return response
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = ['ServerDecoder', 'ClientDecoder']
pymodbus-1.3.2/pymodbus/client/ 0000755 0001750 0001750 00000000000 13150360615 014633 5 ustar wmb wmb pymodbus-1.3.2/pymodbus/client/async.py 0000644 0001750 0001750 00000017174 13150360615 016334 0 ustar wmb wmb """
Implementation of a Modbus Client Using Twisted
--------------------------------------------------
Example run::
from twisted.internet import reactor, protocol
from pymodbus.client.async import ModbusClientProtocol
def printResult(result):
print "Result: %d" % result.bits[0]
def process(client):
result = client.write_coil(1, True)
result.addCallback(printResult)
reactor.callLater(1, reactor.stop)
defer = protocol.ClientCreator(reactor, ModbusClientProtocol
).connectTCP("localhost", 502)
defer.addCallback(process)
Another example::
from twisted.internet import reactor
from pymodbus.client.async import ModbusClientFactory
def process():
factory = reactor.connectTCP("localhost", 502, ModbusClientFactory())
reactor.stop()
if __name__ == "__main__":
reactor.callLater(1, process)
reactor.run()
"""
from twisted.internet import defer, protocol
from pymodbus.factory import ClientDecoder
from pymodbus.exceptions import ConnectionException
from pymodbus.transaction import ModbusSocketFramer
from pymodbus.transaction import FifoTransactionManager
from pymodbus.transaction import DictTransactionManager
from pymodbus.client.common import ModbusClientMixin
from twisted.python.failure import Failure
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# Connected 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.
'''
def __init__(self, framer=None, **kwargs):
''' Initializes the framer module
:param framer: The framer to use for the protocol
'''
self._connected = False
self.framer = framer or ModbusSocketFramer(ClientDecoder())
if isinstance(self.framer, ModbusSocketFramer):
self.transaction = DictTransactionManager(self, **kwargs)
else: self.transaction = FifoTransactionManager(self, **kwargs)
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
for tid in list(self.transaction):
self.transaction.getTransaction(tid).errback(Failure(
ConnectionException('Connection lost during request')))
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._handleResponse)
def execute(self, request):
''' Starts the producer to send the next request to
consumer.write(Frame(request))
'''
request.transaction_id = self.transaction.getNextTID()
packet = self.framer.buildPacket(request)
self.transport.write(packet)
return self._buildResponse(request.transaction_id)
def _handleResponse(self, reply):
''' Handle the processed response and link to correct deferred
:param reply: The reply to process
'''
if reply is not None:
tid = reply.transaction_id
handler = self.transaction.getTransaction(tid)
if handler:
handler.callback(reply)
else: _logger.debug("Unrequested message: " + str(reply))
def _buildResponse(self, tid):
''' Helper method to return a deferred response
for the current request.
:param tid: The transaction identifier for this response
:returns: A defer linked to the latest request
'''
if not self._connected:
return defer.fail(Failure(
ConnectionException('Client is not connected')))
d = defer.Deferred()
self.transaction.addTransaction(d, tid)
return d
#----------------------------------------------------------------------#
# Extra Functions
#----------------------------------------------------------------------#
#if send_failed:
# if self.retry > 0:
# deferLater(clock, self.delay, send, message)
# self.retry -= 1
#---------------------------------------------------------------------------#
# Not Connected Client Protocol
#---------------------------------------------------------------------------#
class ModbusUdpClientProtocol(protocol.DatagramProtocol, ModbusClientMixin):
'''
This represents the base modbus client protocol. All the application
layer code is deferred to a higher level wrapper.
'''
def __init__(self, framer=None, **kwargs):
''' Initializes the framer module
:param framer: The framer to use for the protocol
'''
self.framer = framer or ModbusSocketFramer(ClientDecoder())
if isinstance(self.framer, ModbusSocketFramer):
self.transaction = DictTransactionManager(self, **kwargs)
else: self.transaction = FifoTransactionManager(self, **kwargs)
def datagramReceived(self, data, params):
''' Get response, check for valid message, decode result
:param data: The data returned from the server
:param params: The host parameters sending the datagram
'''
_logger.debug("Datagram from: %s:%d" % params)
self.framer.processIncomingPacket(data, self._handleResponse)
def execute(self, request):
''' Starts the producer to send the next request to
consumer.write(Frame(request))
'''
request.transaction_id = self.transaction.getNextTID()
packet = self.framer.buildPacket(request)
self.transport.write(packet)
return self._buildResponse(request.transaction_id)
def _handleResponse(self, reply):
''' Handle the processed response and link to correct deferred
:param reply: The reply to process
'''
if reply is not None:
tid = reply.transaction_id
handler = self.transaction.getTransaction(tid)
if handler:
handler.callback(reply)
else: _logger.debug("Unrequested message: " + str(reply))
def _buildResponse(self, tid):
''' Helper method to return a deferred response
for the current request.
:param tid: The transaction identifier for this response
:returns: A defer linked to the latest request
'''
d = defer.Deferred()
self.transaction.addTransaction(d, tid)
return d
#---------------------------------------------------------------------------#
# Client Factories
#---------------------------------------------------------------------------#
class ModbusClientFactory(protocol.ReconnectingClientFactory):
''' Simple client protocol factory '''
protocol = ModbusClientProtocol
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"ModbusClientProtocol", "ModbusUdpClientProtocol",
"ModbusClientFactory",
]
pymodbus-1.3.2/pymodbus/client/sync.py 0000644 0001750 0001750 00000035471 13150360615 016173 0 ustar wmb wmb import socket
import serial
import time
from pymodbus.constants import Defaults
from pymodbus.factory import ClientDecoder
from pymodbus.compat import byte2int
from pymodbus.exceptions import NotImplementedException, ParameterException
from pymodbus.exceptions import ConnectionException
from pymodbus.transaction import FifoTransactionManager
from pymodbus.transaction import DictTransactionManager
from pymodbus.transaction import ModbusSocketFramer, ModbusBinaryFramer
from pymodbus.transaction import ModbusAsciiFramer, ModbusRtuFramer
from pymodbus.client.common import ModbusClientMixin
#---------------------------------------------------------------------------#
# Logging
#---------------------------------------------------------------------------#
import logging
_logger = logging.getLogger(__name__)
#---------------------------------------------------------------------------#
# The Synchronous Clients
#---------------------------------------------------------------------------#
class BaseModbusClient(ModbusClientMixin):
'''
Inteface for a modbus synchronous client. Defined here are all the
methods for performing the related request methods. Derived classes
simply need to implement the transport methods and set the correct
framer.
'''
def __init__(self, framer, **kwargs):
''' Initialize a client instance
:param framer: The modbus framer implementation to use
'''
self.framer = framer
if isinstance(self.framer, ModbusSocketFramer):
self.transaction = DictTransactionManager(self, **kwargs)
else: self.transaction = FifoTransactionManager(self, **kwargs)
#-----------------------------------------------------------------------#
# Client interface
#-----------------------------------------------------------------------#
def connect(self):
''' Connect to the modbus remote host
:returns: True if connection succeeded, False otherwise
'''
raise NotImplementedException("Method not implemented by derived class")
def close(self):
''' Closes the underlying socket connection
'''
pass
def _send(self, request):
''' Sends data on the underlying socket
:param request: The encoded request to send
:return: The number of bytes written
'''
raise NotImplementedException("Method not implemented by derived class")
def _recv(self, size):
''' Reads data from the underlying descriptor
:param size: The number of bytes to read
:return: The bytes read
'''
raise NotImplementedException("Method not implemented by derived class")
#-----------------------------------------------------------------------#
# Modbus client methods
#-----------------------------------------------------------------------#
def execute(self, request=None):
'''
:param request: The request to process
:returns: The result of the request execution
'''
if not self.connect():
raise ConnectionException("Failed to connect[%s]" % (self.__str__()))
return self.transaction.execute(request)
#-----------------------------------------------------------------------#
# The magic methods
#-----------------------------------------------------------------------#
def __enter__(self):
''' Implement the client with enter block
:returns: The current instance of the client
'''
if not self.connect():
raise ConnectionException("Failed to connect[%s]" % (self.__str__()))
return self
def __exit__(self, klass, value, traceback):
''' Implement the client with exit block '''
self.close()
def __str__(self):
''' Builds a string representation of the connection
:returns: The string representation
'''
return "Null Transport"
#---------------------------------------------------------------------------#
# Modbus TCP Client Transport Implementation
#---------------------------------------------------------------------------#
class ModbusTcpClient(BaseModbusClient):
''' Implementation of a modbus tcp client
'''
def __init__(self, host='127.0.0.1', port=Defaults.Port,
framer=ModbusSocketFramer, **kwargs):
''' Initialize a client instance
:param host: The host to connect to (default 127.0.0.1)
:param port: The modbus port to connect to (default 502)
:param source_address: The source address tuple to bind to (default ('', 0))
:param timeout: The timeout to use for this socket (default Defaults.Timeout)
:param framer: The modbus framer to use (default ModbusSocketFramer)
.. note:: The host argument will accept ipv4 and ipv6 hosts
'''
self.host = host
self.port = port
self.source_address = kwargs.get('source_address', ('', 0))
self.socket = None
self.timeout = kwargs.get('timeout', Defaults.Timeout)
BaseModbusClient.__init__(self, framer(ClientDecoder()), **kwargs)
def connect(self):
''' Connect to the modbus tcp server
:returns: True if connection succeeded, False otherwise
'''
if self.socket: return True
try:
self.socket = socket.create_connection((self.host, self.port),
timeout=self.timeout, source_address=self.source_address)
except socket.error as msg:
_logger.error('Connection to (%s, %s) failed: %s' % \
(self.host, self.port, msg))
self.close()
return self.socket != None
def close(self):
''' Closes the underlying socket connection
'''
if self.socket:
self.socket.close()
self.socket = None
def _send(self, request):
''' Sends data on the underlying socket
:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
raise ConnectionException(self.__str__())
if request:
return self.socket.send(request)
return 0
def _recv(self, size):
''' Reads data from the underlying descriptor
:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
raise ConnectionException(self.__str__())
return self.socket.recv(size)
def __str__(self):
''' Builds a string representation of the connection
:returns: The string representation
'''
return "%s:%s" % (self.host, self.port)
#---------------------------------------------------------------------------#
# Modbus UDP Client Transport Implementation
#---------------------------------------------------------------------------#
class ModbusUdpClient(BaseModbusClient):
''' Implementation of a modbus udp client
'''
def __init__(self, host='127.0.0.1', port=Defaults.Port,
framer=ModbusSocketFramer, **kwargs):
''' Initialize a client instance
:param host: The host to connect to (default 127.0.0.1)
:param port: The modbus port to connect to (default 502)
:param framer: The modbus framer to use (default ModbusSocketFramer)
:param timeout: The timeout to use for this socket (default None)
'''
self.host = host
self.port = port
self.socket = None
self.timeout = kwargs.get('timeout', None)
BaseModbusClient.__init__(self, framer(ClientDecoder()), **kwargs)
@classmethod
def _get_address_family(cls, address):
''' A helper method to get the correct address family
for a given address.
:param address: The address to get the af for
:returns: AF_INET for ipv4 and AF_INET6 for ipv6
'''
try:
_ = socket.inet_pton(socket.AF_INET6, address)
except socket.error: # not a valid ipv6 address
return socket.AF_INET
return socket.AF_INET6
def connect(self):
''' Connect to the modbus tcp server
:returns: True if connection succeeded, False otherwise
'''
if self.socket: return True
try:
family = ModbusUdpClient._get_address_family(self.host)
self.socket = socket.socket(family, socket.SOCK_DGRAM)
self.socket.settimeout(self.timeout)
except socket.error as ex:
_logger.error('Unable to create udp socket %s' % ex)
self.close()
return self.socket != None
def close(self):
''' Closes the underlying socket connection
'''
self.socket = None
def _send(self, request):
''' Sends data on the underlying socket
:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
raise ConnectionException(self.__str__())
if request:
return self.socket.sendto(request, (self.host, self.port))
return 0
def _recv(self, size):
''' Reads data from the underlying descriptor
:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
raise ConnectionException(self.__str__())
return self.socket.recvfrom(size)[0]
def __str__(self):
''' Builds a string representation of the connection
:returns: The string representation
'''
return "%s:%s" % (self.host, self.port)
#---------------------------------------------------------------------------#
# Modbus Serial Client Transport Implementation
#---------------------------------------------------------------------------#
class ModbusSerialClient(BaseModbusClient):
''' Implementation of a modbus serial client
'''
def __init__(self, method='ascii', **kwargs):
''' Initialize a serial client instance
The methods to connect are::
- ascii
- rtu
- binary
:param method: The method to use for connection
:param port: The serial port to attach to
:param stopbits: The number of stop bits to use
:param bytesize: The bytesize of the serial messages
:param parity: Which kind of parity to use
:param baudrate: The baud rate to use for the serial device
:param timeout: The timeout between serial requests (default 3s)
'''
self.method = method
self.socket = None
BaseModbusClient.__init__(self, self.__implementation(method), **kwargs)
self.port = kwargs.get('port', 0)
self.stopbits = kwargs.get('stopbits', Defaults.Stopbits)
self.bytesize = kwargs.get('bytesize', Defaults.Bytesize)
self.parity = kwargs.get('parity', Defaults.Parity)
self.baudrate = kwargs.get('baudrate', Defaults.Baudrate)
self.timeout = kwargs.get('timeout', Defaults.Timeout)
if self.method == "rtu":
self._last_frame_end = 0.0
if self.baudrate > 19200:
self._silent_interval = 1.75/1000 # ms
else:
self._silent_interval = 3.5 * (1 + 8 + 2) / self.baudrate
@staticmethod
def __implementation(method):
''' Returns the requested framer
:method: The serial framer to instantiate
:returns: The requested serial framer
'''
method = method.lower()
if method == 'ascii': return ModbusAsciiFramer(ClientDecoder())
elif method == 'rtu': return ModbusRtuFramer(ClientDecoder())
elif method == 'binary': return ModbusBinaryFramer(ClientDecoder())
elif method == 'socket': return ModbusSocketFramer(ClientDecoder())
raise ParameterException("Invalid framer method requested")
def connect(self):
''' Connect to the modbus serial server
:returns: True if connection succeeded, False otherwise
'''
if self.socket: return True
try:
self.socket = serial.Serial(port=self.port, timeout=self.timeout,
bytesize=self.bytesize, stopbits=self.stopbits,
baudrate=self.baudrate, parity=self.parity)
except serial.SerialException as msg:
_logger.error(msg)
self.close()
if self.method == "rtu":
self._last_frame_end = time.time()
return self.socket != None
def close(self):
''' Closes the underlying socket connection
'''
if self.socket:
self.socket.close()
self.socket = None
def _send(self, request):
''' Sends data on the underlying socket
If receive buffer still holds some data then flush it.
Sleep if last send finished less than 3.5 character
times ago.
:param request: The encoded request to send
:return: The number of bytes written
'''
if not self.socket:
raise ConnectionException(self.__str__())
if request:
ts = time.time()
if self.method == "rtu":
if ts < self._last_frame_end + self._silent_interval:
_logger.debug("will sleep to wait for 3.5 char")
time.sleep(self._last_frame_end + self._silent_interval - ts)
try:
in_waiting = "in_waiting" if hasattr(self.socket, "in_waiting") else "inWaiting"
if in_waiting == "in_waiting":
waitingbytes = getattr(self.socket, in_waiting)
else:
waitingbytes = getattr(self.socket, in_waiting)()
if waitingbytes:
result = self.socket.read(waitingbytes)
if _logger.isEnabledFor(logging.WARNING):
_logger.warning("cleanup recv buffer before send: " + " ".join([hex(byte2int(x)) for x in result]))
except NotImplementedError:
pass
size = self.socket.write(request)
if self.method == "rtu":
self._last_frame_end = time.time()
return size
return 0
def _recv(self, size):
''' Reads data from the underlying descriptor
:param size: The number of bytes to read
:return: The bytes read
'''
if not self.socket:
raise ConnectionException(self.__str__())
result = self.socket.read(size)
if self.method == "rtu":
self._last_frame_end = time.time()
return result
def __str__(self):
''' Builds a string representation of the connection
:returns: The string representation
'''
return "%s baud[%s]" % (self.method, self.baudrate)
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"ModbusTcpClient", "ModbusUdpClient", "ModbusSerialClient"
] pymodbus-1.3.2/pymodbus/client/__init__.py 0000644 0001750 0001750 00000000000 13150360615 016732 0 ustar wmb wmb pymodbus-1.3.2/pymodbus/client/common.py 0000644 0001750 0001750 00000012626 13150360615 016504 0 ustar wmb wmb '''
Modbus Client Common
----------------------------------
This is a common client mixin that can be used by
both the synchronous and asynchronous clients to
simplify the interface.
'''
from pymodbus.bit_read_message import *
from pymodbus.bit_write_message import *
from pymodbus.register_read_message import *
from pymodbus.register_write_message import *
from pymodbus.diag_message import *
from pymodbus.file_message import *
from pymodbus.other_message import *
class ModbusClientMixin(object):
'''
This is a modbus client mixin that provides additional factory
methods for all the current modbus methods. This can be used
instead of the normal pattern of::
# instead of this
client = ModbusClient(...)
request = ReadCoilsRequest(1,10)
response = client.execute(request)
# now like this
client = ModbusClient(...)
response = client.read_coils(1, 10)
'''
def read_coils(self, address, count=1, **kwargs):
'''
:param address: The starting address to read from
:param count: The number of coils to read
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = ReadCoilsRequest(address, count, **kwargs)
return self.execute(request)
def read_discrete_inputs(self, address, count=1, **kwargs):
'''
:param address: The starting address to read from
:param count: The number of discretes to read
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = ReadDiscreteInputsRequest(address, count, **kwargs)
return self.execute(request)
def write_coil(self, address, value, **kwargs):
'''
:param address: The starting address to write to
:param value: The value to write to the specified address
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = WriteSingleCoilRequest(address, value, **kwargs)
return self.execute(request)
def write_coils(self, address, values, **kwargs):
'''
:param address: The starting address to write to
:param values: The values to write to the specified address
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = WriteMultipleCoilsRequest(address, values, **kwargs)
return self.execute(request)
def write_register(self, address, value, **kwargs):
'''
:param address: The starting address to write to
:param value: The value to write to the specified address
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = WriteSingleRegisterRequest(address, value, **kwargs)
return self.execute(request)
def write_registers(self, address, values, **kwargs):
'''
:param address: The starting address to write to
:param values: The values to write to the specified address
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = WriteMultipleRegistersRequest(address, values, **kwargs)
return self.execute(request)
def read_holding_registers(self, address, count=1, **kwargs):
'''
:param address: The starting address to read from
:param count: The number of registers to read
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = ReadHoldingRegistersRequest(address, count, **kwargs)
return self.execute(request)
def read_input_registers(self, address, count=1, **kwargs):
'''
:param address: The starting address to read from
:param count: The number of registers to read
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = ReadInputRegistersRequest(address, count, **kwargs)
return self.execute(request)
def readwrite_registers(self, *args, **kwargs):
'''
:param read_address: The address to start reading from
:param read_count: The number of registers to read from address
:param write_address: The address to start writing to
:param write_registers: The registers to write to the specified address
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = ReadWriteMultipleRegistersRequest(*args, **kwargs)
return self.execute(request)
def mask_write_register(self, *args, **kwargs):
'''
:param address: The address of the register to write
:param and_mask: The and bitmask to apply to the register address
:param or_mask: The or bitmask to apply to the register address
:param unit: The slave unit this request is targeting
:returns: A deferred response handle
'''
request = MaskWriteRegisterRequest(*args, **kwargs)
return self.execute(request)
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [ 'ModbusClientMixin' ]
pymodbus-1.3.2/pymodbus/exceptions.py 0000644 0001750 0001750 00000005435 13150360615 016117 0 ustar wmb wmb '''
Pymodbus Exceptions
--------------------
Custom exceptions to be used in the Modbus code.
'''
class ModbusException(Exception):
''' Base modbus exception '''
def __init__(self, string):
''' Initialize the exception
:param string: The message to append to the error
'''
self.string = string
def __str__(self):
return 'Modbus Error: %s' % self.string
class ModbusIOException(ModbusException):
''' Error resulting from data i/o '''
def __init__(self, string=""):
''' Initialize the exception
:param string: The message to append to the error
'''
message = "[Input/Output] %s" % string
ModbusException.__init__(self, message)
class ParameterException(ModbusException):
''' Error resulting from invalid parameter '''
def __init__(self, string=""):
''' Initialize the exception
:param string: The message to append to the error
'''
message = "[Invalid Parameter] %s" % string
ModbusException.__init__(self, message)
class NoSuchSlaveException(ModbusException):
''' Error resulting from making a request to a slave
that does not exist '''
def __init__(self, string=""):
''' Initialize the exception
:param string: The message to append to the error
'''
message = "[No Such Slave] %s" % string
ModbusException.__init__(self, message)
class NotImplementedException(ModbusException):
''' Error resulting from not implemented function '''
def __init__(self, string=""):
''' Initialize the exception
:param string: The message to append to the error
'''
message = "[Not Implemented] %s" % string
ModbusException.__init__(self, message)
class ConnectionException(ModbusException):
''' Error resulting from a bad connection '''
def __init__(self, string=""):
''' Initialize the exception
:param string: The message to append to the error
'''
message = "[Connection] %s" % string
ModbusException.__init__(self, message)
class InvalidMessageRecievedException(ModbusException):
"""
Error resulting from invalid response received or decoded
"""
def __init__(self, string=""):
''' Initialize the exception
:param string: The message to append to the error
'''
message = "[Invalid Message] %s" % string
ModbusException.__init__(self, message)
#---------------------------------------------------------------------------#
# Exported symbols
#---------------------------------------------------------------------------#
__all__ = [
"ModbusException", "ModbusIOException",
"ParameterException", "NotImplementedException",
"ConnectionException", "NoSuchSlaveException",
]
pymodbus-1.3.2/pymodbus/compat.py 0000644 0001750 0001750 00000006643 13150360615 015223 0 ustar wmb wmb '''
Python 2.x/3.x Compatibility Layer
-------------------------------------------------
This is mostly based on the jinja2 compat code:
Some py2/py3 compatibility support based on a stripped down
version of six so we don't have to depend on a specific version
of it.
:copyright: Copyright 2013 by the Jinja team, see AUTHORS.
:license: BSD, see LICENSE for details.
'''
import sys
import struct
#---------------------------------------------------------------------------#
# python version checks
#---------------------------------------------------------------------------#
IS_PYTHON2 = sys.version_info[0] == 2
IS_PYTHON3 = sys.version_info[0] == 3
IS_PYPY = hasattr(sys, 'pypy_translation_info')
IS_JYTHON = sys.platform.startswith('java')
#---------------------------------------------------------------------------#
# python > 3.3 compatability layer
#---------------------------------------------------------------------------#
if not IS_PYTHON2:
#-----------------------------------------------------------------------#
# portable builtins
#-----------------------------------------------------------------------#
int2byte = lambda b: struct.pack('B', b)
byte2int = lambda b: b
unichr = chr
range_type = range
text_type = str
string_types = (str,)
iterkeys = lambda d: iter(d.keys())
itervalues = lambda d: iter(d.values())
iteritems = lambda d: iter(d.items())
get_next = lambda x: x.__next__()
#-----------------------------------------------------------------------#
# module renames
#-----------------------------------------------------------------------#
from io import BytesIO, StringIO
NativeStringIO = StringIO
ifilter = filter
imap = map
izip = zip
intern = sys.intern
import socketserver
#-----------------------------------------------------------------------#
# decorators
#-----------------------------------------------------------------------#
implements_to_string = lambda x: x
#---------------------------------------------------------------------------#
# python > 2.5 compatability layer
#---------------------------------------------------------------------------#
else:
#-----------------------------------------------------------------------#
# portable builtins
#-----------------------------------------------------------------------#
int2byte = chr
byte2int = ord
unichr = unichr
text_type = unicode
range_type = xrange
string_types = (str, unicode)
iterkeys = lambda d: d.iterkeys()
itervalues = lambda d: d.itervalues()
iteritems = lambda d: d.iteritems()
get_next = lambda x: x.next()
#-----------------------------------------------------------------------#
# module renames
#-----------------------------------------------------------------------#
from cStringIO import StringIO as BytesIO, StringIO
NativeStringIO = BytesIO
from itertools import imap, izip, ifilter
intern = intern
import SocketServer as socketserver
#-----------------------------------------------------------------------#
# decorators
#-----------------------------------------------------------------------#
def implements_to_string(klass):
klass.__unicode__ = klass.__str__
klass.__str__ = lambda x: x.__unicode__().encode('utf-8')
return klass
pymodbus-1.3.2/requirements.txt 0000644 0001750 0001750 00000002076 13150360615 015004 0 ustar wmb wmb coloredlogs>=7.0
# -------------------------------------------------------------------
# if want to use the pymodbus serial stack, uncomment these
# -------------------------------------------------------------------
#pyserial==3.3
# -------------------------------------------------------------------
# if you want to run the tests and code coverage, uncomment these
# -------------------------------------------------------------------
#coverage==4.4
#mock==2.0.0
#nose==1.3.7
#pep8==1.7.0
# -------------------------------------------------------------------
# if you want to use the asynchronous version, uncomment these
# -------------------------------------------------------------------
#Twisted==17.1.0
#zope.interface==4.4.0
#pyasn1==0.2.3
#pycrypto==2.6.1
#wsgiref==0.1.2
#cryptography==1.8.1
# -------------------------------------------------------------------
# if you want to build the documentation, uncomment these
# -------------------------------------------------------------------
#Jinja2==2.9.6
#Pygments==2.2.0
#Sphinx==1.5.5
#docutils==0.13.1
#pydoctor==16.3.0
pymodbus-1.3.2/doc/ 0000755 0001750 0001750 00000000000 13150640276 012264 5 ustar wmb wmb pymodbus-1.3.2/doc/quality/ 0000755 0001750 0001750 00000000000 13150635760 013756 5 ustar wmb wmb pymodbus-1.3.2/doc/quality/current.coverage 0000644 0001750 0001750 00000004511 13150360615 017150 0 ustar wmb wmb Name Stmts Miss Cover Missing
---------------------------------------------------------------
pymodbus 15 6 60% 24-27, 36-37
pymodbus.bit_read_message 68 0 100%
pymodbus.bit_write_message 95 0 100%
pymodbus.client 0 0 100%
pymodbus.client.async 70 0 100%
pymodbus.client.common 36 0 100%
pymodbus.client.sync 147 0 100%
pymodbus.constants 36 0 100%
pymodbus.datastore 5 0 100%
pymodbus.datastore.context 50 0 100%
pymodbus.datastore.remote 31 0 100%
pymodbus.datastore.store 67 0 100%
pymodbus.device 159 0 100%
pymodbus.diag_message 202 0 100%
pymodbus.events 60 0 100%
pymodbus.exceptions 22 0 100%
pymodbus.factory 77 0 100%
pymodbus.file_message 181 0 100%
pymodbus.interfaces 46 0 100%
pymodbus.internal 0 0 100%
pymodbus.internal.ptwisted 16 2 88% 29-30
pymodbus.mei_message 70 0 100%
pymodbus.other_message 145 0 100%
pymodbus.payload 140 2 99% 205, 224
pymodbus.pdu 72 0 100%
pymodbus.register_read_message 124 0 100%
pymodbus.register_write_message 91 2 98% 39, 148
pymodbus.server 0 0 100%
pymodbus.server.async 113 39 65% 55-58, 65-74, 81-86, 151-156, 163-172, 180-184
pymodbus.server.sync 186 0 100%
pymodbus.transaction 275 53 81% 63-81, 116-117, 259, 263, 403, 433-442, 577-586, 656, 733-742, 768-769
pymodbus.utilities 67 0 100%
pymodbus.version 13 0 100%
---------------------------------------------------------------
TOTAL 2679 104 96%
----------------------------------------------------------------------
Ran 255 tests in 0.981s
OK
pymodbus-1.3.2/doc/quality/current.pep8 0000644 0001750 0001750 00000117476 13150360615 016250 0 ustar wmb wmb running pep8
pymodbus/__init__.py:16:11: E221 multiple spaces before operator
pymodbus/bit_read_message.py:26:19: E221 multiple spaces before operator
pymodbus/bit_read_message.py:143:80: E501 line too long (80 characters)
pymodbus/bit_read_message.py:202:80: E501 line too long (80 characters)
pymodbus/bit_write_message.py:19:14: E221 multiple spaces before operator
pymodbus/bit_write_message.py:58:15: E221 multiple spaces before operator
pymodbus/bit_write_message.py:59:22: E701 multiple statements on one line (colon)
pymodbus/bit_write_message.py:60:13: E701 multiple statements on one line (colon)
pymodbus/bit_write_message.py:117:15: E221 multiple spaces before operator
pymodbus/bit_write_message.py:118:22: E701 multiple statements on one line (colon)
pymodbus/bit_write_message.py:119:13: E701 multiple statements on one line (colon)
pymodbus/bit_write_message.py:160:22: E701 multiple statements on one line (colon)
pymodbus/bit_write_message.py:161:45: E701 multiple statements on one line (colon)
pymodbus/bit_write_message.py:162:20: E221 multiple spaces before operator
pymodbus/bit_write_message.py:170:14: E221 multiple spaces before operator
pymodbus/bit_write_message.py:172:15: E221 multiple spaces before operator
pymodbus/constants.py:74:9: E221 multiple spaces before operator
pymodbus/constants.py:75:12: E221 multiple spaces before operator
pymodbus/constants.py:76:12: E221 multiple spaces before operator
pymodbus/constants.py:77:15: E221 multiple spaces before operator
pymodbus/constants.py:79:15: E221 multiple spaces before operator
pymodbus/constants.py:80:11: E221 multiple spaces before operator
pymodbus/constants.py:81:13: E221 multiple spaces before operator
pymodbus/constants.py:82:11: E221 multiple spaces before operator
pymodbus/constants.py:83:13: E221 multiple spaces before operator
pymodbus/constants.py:84:13: E221 multiple spaces before operator
pymodbus/constants.py:118:12: E221 multiple spaces before operator
pymodbus/constants.py:119:10: E221 multiple spaces before operator
pymodbus/constants.py:120:7: E221 multiple spaces before operator
pymodbus/constants.py:121:8: E221 multiple spaces before operator
pymodbus/constants.py:122:12: E221 multiple spaces before operator
pymodbus/constants.py:145:9: E221 multiple spaces before operator
pymodbus/constants.py:146:8: E221 multiple spaces before operator
pymodbus/constants.py:163:18: E221 multiple spaces before operator
pymodbus/constants.py:193:10: E221 multiple spaces before operator
pymodbus/constants.py:194:12: E221 multiple spaces before operator
pymodbus/constants.py:210:12: E221 multiple spaces before operator
pymodbus/device.py:30:13: E126 continuation line over-indented for hanging indent
pymodbus/device.py:88:41: E203 whitespace before ':'
pymodbus/device.py:89:41: E203 whitespace before ':'
pymodbus/device.py:90:41: E203 whitespace before ':'
pymodbus/device.py:91:41: E203 whitespace before ':'
pymodbus/device.py:92:41: E203 whitespace before ':'
pymodbus/device.py:93:41: E203 whitespace before ':'
pymodbus/device.py:94:41: E203 whitespace before ':'
pymodbus/device.py:96:41: E203 whitespace before ':'
pymodbus/device.py:97:41: E203 whitespace before ':'
pymodbus/device.py:98:41: E203 whitespace before ':'
pymodbus/device.py:99:41: E203 whitespace before ':'
pymodbus/device.py:100:41: E203 whitespace before ':'
pymodbus/device.py:101:41: E203 whitespace before ':'
pymodbus/device.py:102:41: E203 whitespace before ':'
pymodbus/device.py:103:41: E203 whitespace before ':'
pymodbus/device.py:105:41: E203 whitespace before ':'
pymodbus/device.py:106:41: E203 whitespace before ':'
pymodbus/device.py:107:41: E203 whitespace before ':'
pymodbus/device.py:108:41: E203 whitespace before ':'
pymodbus/device.py:109:41: E203 whitespace before ':'
pymodbus/device.py:110:41: E203 whitespace before ':'
pymodbus/device.py:111:41: E203 whitespace before ':'
pymodbus/device.py:112:41: E203 whitespace before ':'
pymodbus/device.py:113:41: E203 whitespace before ':'
pymodbus/device.py:114:41: E203 whitespace before ':'
pymodbus/device.py:115:41: E203 whitespace before ':'
pymodbus/device.py:116:41: E203 whitespace before ':'
pymodbus/device.py:117:41: E203 whitespace before ':'
pymodbus/device.py:118:41: E203 whitespace before ':'
pymodbus/device.py:120:41: E203 whitespace before ':'
pymodbus/device.py:121:41: E203 whitespace before ':'
pymodbus/device.py:122:41: E203 whitespace before ':'
pymodbus/device.py:123:41: E203 whitespace before ':'
pymodbus/device.py:124:41: E203 whitespace before ':'
pymodbus/device.py:125:41: E203 whitespace before ':'
pymodbus/device.py:126:41: E203 whitespace before ':'
pymodbus/device.py:127:41: E203 whitespace before ':'
pymodbus/device.py:128:41: E203 whitespace before ':'
pymodbus/device.py:129:41: E203 whitespace before ':'
pymodbus/device.py:131:41: E203 whitespace before ':'
pymodbus/device.py:132:41: E203 whitespace before ':'
pymodbus/device.py:133:41: E203 whitespace before ':'
pymodbus/device.py:134:41: E203 whitespace before ':'
pymodbus/device.py:135:41: E203 whitespace before ':'
pymodbus/device.py:136:41: E203 whitespace before ':'
pymodbus/device.py:137:41: E203 whitespace before ':'
pymodbus/device.py:138:41: E203 whitespace before ':'
pymodbus/device.py:88:55: E261 at least two spaces before inline comment
pymodbus/device.py:89:55: E261 at least two spaces before inline comment
pymodbus/device.py:90:55: E261 at least two spaces before inline comment
pymodbus/device.py:91:55: E261 at least two spaces before inline comment
pymodbus/device.py:92:55: E261 at least two spaces before inline comment
pymodbus/device.py:93:55: E261 at least two spaces before inline comment
pymodbus/device.py:94:55: E261 at least two spaces before inline comment
pymodbus/device.py:131:55: E261 at least two spaces before inline comment
pymodbus/device.py:132:55: E261 at least two spaces before inline comment
pymodbus/device.py:133:55: E261 at least two spaces before inline comment
pymodbus/device.py:134:55: E261 at least two spaces before inline comment
pymodbus/device.py:135:55: E261 at least two spaces before inline comment
pymodbus/device.py:136:55: E261 at least two spaces before inline comment
pymodbus/device.py:137:55: E261 at least two spaces before inline comment
pymodbus/device.py:138:55: E261 at least two spaces before inline comment
pymodbus/device.py:175:53: E225 missing whitespace around operator
pymodbus/device.py:273:15: E221 multiple spaces before operator
pymodbus/device.py:274:16: E221 multiple spaces before operator
pymodbus/device.py:275:23: E221 multiple spaces before operator
pymodbus/device.py:276:14: E221 multiple spaces before operator
pymodbus/device.py:277:16: E221 multiple spaces before operator
pymodbus/device.py:278:14: E221 multiple spaces before operator
pymodbus/device.py:289:80: E501 line too long (81 characters)
pymodbus/device.py:290:80: E501 line too long (81 characters)
pymodbus/device.py:289:45: E231 missing whitespace after ','
pymodbus/device.py:289:47: E231 missing whitespace after ','
pymodbus/device.py:290:45: E231 missing whitespace after ','
pymodbus/device.py:290:47: E231 missing whitespace after ','
pymodbus/device.py:291:45: E231 missing whitespace after ','
pymodbus/device.py:291:47: E231 missing whitespace after ','
pymodbus/device.py:292:45: E231 missing whitespace after ','
pymodbus/device.py:292:47: E231 missing whitespace after ','
pymodbus/device.py:289:33: E272 multiple spaces before keyword
pymodbus/device.py:290:35: E272 multiple spaces before keyword
pymodbus/device.py:315:17: E201 whitespace after '{'
pymodbus/device.py:315:47: E202 whitespace before '}'
pymodbus/device.py:315:27: E231 missing whitespace after ':'
pymodbus/device.py:401:12: E221 multiple spaces before operator
pymodbus/device.py:442:25: E701 multiple statements on one line (colon)
pymodbus/device.py:449:15: E221 multiple spaces before operator
pymodbus/device.py:451:22: E221 multiple spaces before operator
pymodbus/device.py:452:17: E221 multiple spaces before operator
pymodbus/device.py:453:20: E221 multiple spaces before operator
pymodbus/device.py:454:13: E221 multiple spaces before operator
pymodbus/device.py:455:14: E221 multiple spaces before operator
pymodbus/device.py:456:24: E221 multiple spaces before operator
pymodbus/device.py:457:10: E221 multiple spaces before operator
pymodbus/device.py:478:11: E221 multiple spaces before operator
pymodbus/device.py:479:13: E221 multiple spaces before operator
pymodbus/device.py:527:12: E221 multiple spaces before operator
pymodbus/device.py:528:11: E221 multiple spaces before operator
pymodbus/device.py:529:9: E221 multiple spaces before operator
pymodbus/device.py:612:9: E126 continuation line over-indented for hanging indent
pymodbus/diag_message.py:135:80: E501 line too long (81 characters)
pymodbus/diag_message.py:174:13: E701 multiple statements on one line (colon)
pymodbus/diag_message.py:200:13: E701 multiple statements on one line (colon)
pymodbus/diag_message.py:224:25: E221 multiple spaces before operator
pymodbus/diag_message.py:225:13: E701 multiple statements on one line (colon)
pymodbus/diag_message.py:254:25: E221 multiple spaces before operator
pymodbus/diag_message.py:255:13: E701 multiple statements on one line (colon)
pymodbus/diag_message.py:349:19: E221 multiple spaces before operator
pymodbus/diag_message.py:593:80: E501 line too long (80 characters)
pymodbus/diag_message.py:596:80: E501 line too long (80 characters)
pymodbus/diag_message.py:612:80: E501 line too long (82 characters)
pymodbus/diag_message.py:615:80: E501 line too long (80 characters)
pymodbus/diag_message.py:702:23: E261 at least two spaces before inline comment
pymodbus/diag_message.py:705:13: E701 multiple statements on one line (colon)
pymodbus/diag_message.py:725:80: E501 line too long (80 characters)
pymodbus/diag_message.py:731:80: E501 line too long (90 characters)
pymodbus/diag_message.py:732:80: E501 line too long (82 characters)
pymodbus/diag_message.py:737:80: E501 line too long (96 characters)
pymodbus/events.py:54:21: E221 multiple spaces before operator
pymodbus/events.py:55:20: E221 multiple spaces before operator
pymodbus/events.py:63:13: E221 multiple spaces before operator
pymodbus/events.py:74:21: E221 multiple spaces before operator
pymodbus/events.py:75:20: E221 multiple spaces before operator
pymodbus/events.py:105:18: E221 multiple spaces before operator
pymodbus/events.py:106:25: E221 multiple spaces before operator
pymodbus/events.py:107:24: E221 multiple spaces before operator
pymodbus/events.py:108:23: E221 multiple spaces before operator
pymodbus/events.py:110:20: E221 multiple spaces before operator
pymodbus/events.py:118:13: E128 continuation line under-indented for visual indent
pymodbus/events.py:119:13: E221 multiple spaces before operator
pymodbus/events.py:130:18: E221 multiple spaces before operator
pymodbus/events.py:131:25: E221 multiple spaces before operator
pymodbus/events.py:132:24: E221 multiple spaces before operator
pymodbus/events.py:133:23: E221 multiple spaces before operator
pymodbus/events.py:135:20: E221 multiple spaces before operator
pymodbus/factory.py:44:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:45:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:46:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:47:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:48:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:49:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:50:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:51:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:52:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:54:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:56:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:57:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:58:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:59:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:61:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:62:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:63:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:64:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:66:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:69:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:70:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:71:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:72:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:73:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:74:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:75:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:76:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:77:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:78:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:79:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:80:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:81:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:82:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:83:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:84:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:85:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:87:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:94:80: E501 line too long (83 characters)
pymodbus/factory.py:138:23: E701 multiple statements on one line (colon)
pymodbus/factory.py:152:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:153:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:154:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:155:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:156:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:157:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:158:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:159:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:160:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:162:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:164:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:165:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:166:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:167:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:169:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:170:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:171:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:172:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:174:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:177:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:178:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:179:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:180:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:181:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:182:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:183:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:184:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:185:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:186:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:187:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:188:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:189:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:190:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:191:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:192:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:193:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:195:13: E126 continuation line over-indented for hanging indent
pymodbus/factory.py:202:80: E501 line too long (83 characters)
pymodbus/factory.py:249:23: E701 multiple statements on one line (colon)
pymodbus/file_message.py:30:28: E221 multiple spaces before operator
pymodbus/file_message.py:31:25: E221 multiple spaces before operator
pymodbus/file_message.py:32:27: E221 multiple spaces before operator
pymodbus/file_message.py:33:25: E221 multiple spaces before operator
pymodbus/file_message.py:34:80: E501 line too long (87 characters)
pymodbus/file_message.py:34:27: E221 multiple spaces before operator
pymodbus/file_message.py:35:80: E501 line too long (87 characters)
pymodbus/file_message.py:41:12: E127 continuation line over-indented for visual indent
pymodbus/file_message.py:42:12: E127 continuation line over-indented for visual indent
pymodbus/file_message.py:43:12: E127 continuation line over-indented for visual indent
pymodbus/file_message.py:44:12: E127 continuation line over-indented for visual indent
pymodbus/file_message.py:41:32: E221 multiple spaces before operator
pymodbus/file_message.py:42:34: E221 multiple spaces before operator
pymodbus/file_message.py:43:34: E221 multiple spaces before operator
pymodbus/file_message.py:44:32: E221 multiple spaces before operator
pymodbus/file_message.py:92:21: E221 multiple spaces before operator
pymodbus/file_message.py:102:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:113:62: E225 missing whitespace around operator
pymodbus/file_message.py:115:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:114:19: E221 multiple spaces before operator
pymodbus/file_message.py:116:34: E701 multiple statements on one line (colon)
pymodbus/file_message.py:154:14: E221 multiple spaces before operator
pymodbus/file_message.py:169:80: E501 line too long (87 characters)
pymodbus/file_message.py:169:84: E225 missing whitespace around operator
pymodbus/file_message.py:170:41: E261 at least two spaces before inline comment
pymodbus/file_message.py:172:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:173:38: E701 multiple statements on one line (colon)
pymodbus/file_message.py:192:21: E221 multiple spaces before operator
pymodbus/file_message.py:199:80: E501 line too long (85 characters)
pymodbus/file_message.py:203:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:215:62: E225 missing whitespace around operator
pymodbus/file_message.py:217:18: E221 multiple spaces before operator
pymodbus/file_message.py:219:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:220:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:218:19: E221 multiple spaces before operator
pymodbus/file_message.py:221:34: E701 multiple statements on one line (colon)
pymodbus/file_message.py:248:21: E221 multiple spaces before operator
pymodbus/file_message.py:255:80: E501 line too long (85 characters)
pymodbus/file_message.py:259:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:271:62: E225 missing whitespace around operator
pymodbus/file_message.py:273:18: E221 multiple spaces before operator
pymodbus/file_message.py:275:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:276:17: E128 continuation line under-indented for visual indent
pymodbus/file_message.py:274:19: E221 multiple spaces before operator
pymodbus/file_message.py:277:34: E701 multiple statements on one line (colon)
pymodbus/file_message.py:298:21: E221 multiple spaces before operator
pymodbus/file_message.py:300:21: E221 multiple spaces before operator
pymodbus/file_message.py:331:80: E501 line too long (83 characters)
pymodbus/file_message.py:350:21: E221 multiple spaces before operator
pymodbus/file_message.py:352:21: E221 multiple spaces before operator
pymodbus/mei_message.py:43:13: E128 continuation line under-indented for visual indent
pymodbus/mei_message.py:66:13: E128 continuation line under-indented for visual indent
pymodbus/mei_message.py:91:17: E261 at least two spaces before inline comment
pymodbus/mei_message.py:94:69: E225 missing whitespace around operator
pymodbus/mei_message.py:108:31: E261 at least two spaces before inline comment
pymodbus/mei_message.py:111:35: E261 at least two spaces before inline comment
pymodbus/mei_message.py:120:13: E128 continuation line under-indented for visual indent
pymodbus/mei_message.py:121:13: E128 continuation line under-indented for visual indent
pymodbus/mei_message.py:138:40: E261 at least two spaces before inline comment
pymodbus/mei_message.py:141:80: E501 line too long (80 characters)
pymodbus/mei_message.py:141:77: E225 missing whitespace around operator
pymodbus/mei_message.py:143:53: E225 missing whitespace around operator
pymodbus/other_message.py:187:23: E701 multiple statements on one line (colon)
pymodbus/other_message.py:188:13: E701 multiple statements on one line (colon)
pymodbus/other_message.py:257:28: E203 whitespace before ':'
pymodbus/other_message.py:258:28: E203 whitespace before ':'
pymodbus/other_message.py:259:28: E203 whitespace before ':'
pymodbus/other_message.py:260:28: E203 whitespace before ':'
pymodbus/other_message.py:301:23: E701 multiple statements on one line (colon)
pymodbus/other_message.py:302:13: E701 multiple statements on one line (colon)
pymodbus/other_message.py:303:15: E221 multiple spaces before operator
pymodbus/other_message.py:329:80: E501 line too long (91 characters)
pymodbus/other_message.py:400:23: E701 multiple statements on one line (colon)
pymodbus/other_message.py:401:13: E701 multiple statements on one line (colon)
pymodbus/payload.py:36:21: E221 multiple spaces before operator
pymodbus/payload.py:61:27: E225 missing whitespace around operator
pymodbus/payload.py:186:21: E221 multiple spaces before operator
pymodbus/pdu.py:79:13: E701 multiple statements on one line (colon)
pymodbus/pdu.py:97:17: E128 continuation line under-indented for visual indent
pymodbus/pdu.py:129:20: E221 multiple spaces before operator
pymodbus/pdu.py:130:19: E221 multiple spaces before operator
pymodbus/pdu.py:131:17: E221 multiple spaces before operator
pymodbus/pdu.py:132:17: E221 multiple spaces before operator
pymodbus/pdu.py:133:16: E221 multiple spaces before operator
pymodbus/pdu.py:134:14: E221 multiple spaces before operator
pymodbus/pdu.py:135:22: E221 multiple spaces before operator
pymodbus/pdu.py:136:27: E221 multiple spaces before operator
pymodbus/pdu.py:137:22: E221 multiple spaces before operator
pymodbus/register_read_message.py:128:80: E501 line too long (80 characters)
pymodbus/register_read_message.py:178:80: E501 line too long (80 characters)
pymodbus/register_read_message.py:226:26: E221 multiple spaces before operator
pymodbus/register_read_message.py:227:24: E221 multiple spaces before operator
pymodbus/register_read_message.py:228:27: E221 multiple spaces before operator
pymodbus/register_read_message.py:241:17: E128 continuation line under-indented for visual indent
pymodbus/register_read_message.py:242:17: E128 continuation line under-indented for visual indent
pymodbus/register_read_message.py:241:54: E502 the backslash is redundant between brackets
pymodbus/register_read_message.py:253:9: E122 continuation line missing indentation or outdented
pymodbus/register_read_message.py:254:9: E122 continuation line missing indentation or outdented
pymodbus/register_read_message.py:255:29: E221 multiple spaces before operator
pymodbus/register_write_message.py:133:22: E701 multiple statements on one line (colon)
pymodbus/register_write_message.py:134:45: E701 multiple statements on one line (colon)
pymodbus/register_write_message.py:155:9: E122 continuation line missing indentation or outdented
pymodbus/transaction.py:9:24: E272 multiple spaces before keyword
pymodbus/transaction.py:11:24: E272 multiple spaces before keyword
pymodbus/transaction.py:12:24: E272 multiple spaces before keyword
pymodbus/transaction.py:66:80: E501 line too long (85 characters)
pymodbus/transaction.py:67:22: E702 multiple statements on one line (semicolon)
pymodbus/transaction.py:146:31: E231 missing whitespace after ':'
pymodbus/transaction.py:146:40: E231 missing whitespace after ':'
pymodbus/transaction.py:146:49: E231 missing whitespace after ':'
pymodbus/transaction.py:146:58: E231 missing whitespace after ':'
pymodbus/transaction.py:147:21: E221 multiple spaces before operator
pymodbus/transaction.py:148:21: E221 multiple spaces before operator
pymodbus/transaction.py:159:13: E122 continuation line missing indentation or outdented
pymodbus/transaction.py:160:21: E126 continuation line over-indented for hanging indent
pymodbus/transaction.py:179:31: E231 missing whitespace after ':'
pymodbus/transaction.py:179:40: E231 missing whitespace after ':'
pymodbus/transaction.py:179:49: E231 missing whitespace after ':'
pymodbus/transaction.py:179:58: E231 missing whitespace after ':'
pymodbus/transaction.py:244:17: E701 multiple statements on one line (colon)
pymodbus/transaction.py:253:13: E128 continuation line under-indented for visual indent
pymodbus/transaction.py:254:13: E128 continuation line under-indented for visual indent
pymodbus/transaction.py:255:13: E128 continuation line under-indented for visual indent
pymodbus/transaction.py:305:21: E221 multiple spaces before operator
pymodbus/transaction.py:306:19: E221 multiple spaces before operator
pymodbus/transaction.py:308:21: E221 multiple spaces before operator
pymodbus/transaction.py:380:14: E221 multiple spaces before operator
pymodbus/transaction.py:381:12: E221 multiple spaces before operator
pymodbus/transaction.py:383:19: E701 multiple statements on one line (colon)
pymodbus/transaction.py:423:17: E701 multiple statements on one line (colon)
pymodbus/transaction.py:432:13: E128 continuation line under-indented for visual indent
pymodbus/transaction.py:433:13: E128 continuation line under-indented for visual indent
pymodbus/transaction.py:463:31: E231 missing whitespace after ':'
pymodbus/transaction.py:463:45: E231 missing whitespace after ':'
pymodbus/transaction.py:463:54: E231 missing whitespace after ':'
pymodbus/transaction.py:464:21: E221 multiple spaces before operator
pymodbus/transaction.py:465:21: E221 multiple spaces before operator
pymodbus/transaction.py:466:19: E221 multiple spaces before operator
pymodbus/transaction.py:467:21: E221 multiple spaces before operator
pymodbus/transaction.py:478:23: E701 multiple statements on one line (colon)
pymodbus/transaction.py:479:21: E203 whitespace before ':'
pymodbus/transaction.py:499:31: E231 missing whitespace after ':'
pymodbus/transaction.py:499:45: E231 missing whitespace after ':'
pymodbus/transaction.py:499:54: E231 missing whitespace after ':'
pymodbus/transaction.py:524:14: E221 multiple spaces before operator
pymodbus/transaction.py:525:12: E221 multiple spaces before operator
pymodbus/transaction.py:527:19: E701 multiple statements on one line (colon)
pymodbus/transaction.py:567:17: E701 multiple statements on one line (colon)
pymodbus/transaction.py:576:16: E221 multiple spaces before operator
pymodbus/transaction.py:577:15: E221 multiple spaces before operator
pymodbus/transaction.py:620:31: E231 missing whitespace after ':'
pymodbus/transaction.py:620:45: E231 missing whitespace after ':'
pymodbus/transaction.py:620:54: E231 missing whitespace after ':'
pymodbus/transaction.py:621:21: E221 multiple spaces before operator
pymodbus/transaction.py:622:21: E221 multiple spaces before operator
pymodbus/transaction.py:623:19: E221 multiple spaces before operator
pymodbus/transaction.py:624:21: E221 multiple spaces before operator
pymodbus/transaction.py:635:23: E701 multiple statements on one line (colon)
pymodbus/transaction.py:636:21: E203 whitespace before ':'
pymodbus/transaction.py:643:80: E501 line too long (85 characters)
pymodbus/transaction.py:655:31: E231 missing whitespace after ':'
pymodbus/transaction.py:655:45: E231 missing whitespace after ':'
pymodbus/transaction.py:655:54: E231 missing whitespace after ':'
pymodbus/transaction.py:680:14: E221 multiple spaces before operator
pymodbus/transaction.py:681:12: E221 multiple spaces before operator
pymodbus/transaction.py:683:19: E701 multiple statements on one line (colon)
pymodbus/transaction.py:723:17: E701 multiple statements on one line (colon)
pymodbus/transaction.py:733:13: E128 continuation line under-indented for visual indent
pymodbus/transaction.py:734:13: E128 continuation line under-indented for visual indent
pymodbus/transaction.py:749:31: E701 multiple statements on one line (colon)
pymodbus/transaction.py:750:17: E701 multiple statements on one line (colon)
pymodbus/utilities.py:64:15: E701 multiple statements on one line (colon)
pymodbus/utilities.py:69:13: E701 multiple statements on one line (colon)
pymodbus/utilities.py:110:17: E701 multiple statements on one line (colon)
pymodbus/utilities.py:131:51: E702 multiple statements on one line (semicolon)
pymodbus/client/async.py:115:17: E701 multiple statements on one line (colon)
pymodbus/client/async.py:130:32: E261 at least two spaces before inline comment
pymodbus/client/async.py:187:17: E701 multiple statements on one line (colon)
pymodbus/client/async.py:198:32: E261 at least two spaces before inline comment
pymodbus/client/sync.py:47:80: E501 line too long (80 characters)
pymodbus/client/sync.py:60:80: E501 line too long (80 characters)
pymodbus/client/sync.py:68:80: E501 line too long (80 characters)
pymodbus/client/sync.py:79:80: E501 line too long (81 characters)
pymodbus/client/sync.py:93:80: E501 line too long (81 characters)
pymodbus/client/sync.py:137:23: E701 multiple statements on one line (colon)
pymodbus/client/sync.py:139:80: E501 line too long (92 characters)
pymodbus/client/sync.py:143:17: E128 continuation line under-indented for visual indent
pymodbus/client/sync.py:142:65: E502 the backslash is redundant between brackets
pymodbus/client/sync.py:145:28: E711 comparison to None should be 'if cond is not None:'
pymodbus/client/sync.py:212:29: E261 at least two spaces before inline comment
pymodbus/client/sync.py:221:23: E701 multiple statements on one line (colon)
pymodbus/client/sync.py:228:28: E711 comparison to None should be 'if cond is not None:'
pymodbus/client/sync.py:289:20: E221 multiple spaces before operator
pymodbus/client/sync.py:290:20: E221 multiple spaces before operator
pymodbus/client/sync.py:293:18: E221 multiple spaces before operator
pymodbus/client/sync.py:296:20: E221 multiple spaces before operator
pymodbus/client/sync.py:298:21: E221 multiple spaces before operator
pymodbus/client/sync.py:308:31: E701 multiple statements on one line (colon)
pymodbus/client/sync.py:308:32: E272 multiple spaces before keyword
pymodbus/client/sync.py:309:29: E701 multiple statements on one line (colon)
pymodbus/client/sync.py:309:30: E272 multiple spaces before keyword
pymodbus/client/sync.py:310:32: E701 multiple statements on one line (colon)
pymodbus/client/sync.py:318:23: E701 multiple statements on one line (colon)
pymodbus/client/sync.py:321:17: E128 continuation line under-indented for visual indent
pymodbus/client/sync.py:322:17: E128 continuation line under-indented for visual indent
pymodbus/client/sync.py:326:28: E711 comparison to None should be 'if cond is not None:'
pymodbus/server/async.py:218:5: E128 continuation line under-indented for visual indent
pymodbus/server/async.py:218:5: E125 continuation line does not distinguish itself from next logical line
pymodbus/server/async.py:236:43: E261 at least two spaces before inline comment
pymodbus/server/sync.py:78:80: E501 line too long (81 characters)
pymodbus/server/sync.py:80:80: E501 line too long (81 characters)
pymodbus/server/sync.py:84:80: E501 line too long (80 characters)
pymodbus/server/sync.py:91:80: E501 line too long (80 characters)
pymodbus/server/sync.py:110:34: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:113:19: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:140:28: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:144:34: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:148:19: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:177:28: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:181:34: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:185:19: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:224:30: E272 multiple spaces before keyword
pymodbus/server/sync.py:224:20: E221 multiple spaces before operator
pymodbus/server/sync.py:232:13: E128 continuation line under-indented for visual indent
pymodbus/server/sync.py:248:35: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:273:30: E272 multiple spaces before keyword
pymodbus/server/sync.py:273:20: E221 multiple spaces before operator
pymodbus/server/sync.py:281:13: E128 continuation line under-indented for visual indent
pymodbus/server/sync.py:289:33: E261 at least two spaces before inline comment
pymodbus/server/sync.py:298:35: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:329:30: E272 multiple spaces before keyword
pymodbus/server/sync.py:329:20: E221 multiple spaces before operator
pymodbus/server/sync.py:336:20: E221 multiple spaces before operator
pymodbus/server/sync.py:339:20: E221 multiple spaces before operator
pymodbus/server/sync.py:341:21: E221 multiple spaces before operator
pymodbus/server/sync.py:342:20: E221 multiple spaces before operator
pymodbus/server/sync.py:350:23: E701 multiple statements on one line (colon)
pymodbus/server/sync.py:353:17: E128 continuation line under-indented for visual indent
pymodbus/server/sync.py:354:17: E128 continuation line under-indented for visual indent
pymodbus/server/sync.py:358:28: E711 comparison to None should be 'if cond is not None:'
pymodbus/server/sync.py:370:13: E128 continuation line under-indented for visual indent
pymodbus/server/sync.py:381:19: E701 multiple statements on one line (colon)
pymodbus/internal/ptwisted.py:53:15: E701 multiple statements on one line (colon)
pymodbus/datastore/context.py:9:15: E702 multiple statements on one line (semicolon)
pymodbus/datastore/context.py:101:20: E221 multiple spaces before operator
pymodbus/datastore/context.py:128:23: E701 multiple statements on one line (colon)
pymodbus/datastore/context.py:131:13: E701 multiple statements on one line (colon)
pymodbus/datastore/context.py:139:23: E701 multiple statements on one line (colon)
pymodbus/datastore/context.py:142:80: E501 line too long (82 characters)
pymodbus/datastore/context.py:142:13: E701 multiple statements on one line (colon)
pymodbus/datastore/database.py:13:15: E702 multiple statements on one line (semicolon)
pymodbus/datastore/database.py:83:80: E501 line too long (80 characters)
pymodbus/datastore/database.py:85:80: E501 line too long (80 characters)
pymodbus/datastore/database.py:95:13: E128 continuation line under-indented for visual indent
pymodbus/datastore/database.py:110:14: E221 multiple spaces before operator
pymodbus/datastore/database.py:128:28: E203 whitespace before ':'
pymodbus/datastore/database.py:129:28: E203 whitespace before ':'
pymodbus/datastore/database.py:130:28: E203 whitespace before ':'
pymodbus/datastore/database.py:142:14: E221 multiple spaces before operator
pymodbus/datastore/database.py:143:15: E221 multiple spaces before operator
pymodbus/datastore/database.py:154:14: E221 multiple spaces before operator
pymodbus/datastore/database.py:155:14: E221 multiple spaces before operator
pymodbus/datastore/database.py:156:31: E221 multiple spaces before operator
pymodbus/datastore/database.py:158:15: E221 multiple spaces before operator
pymodbus/datastore/database.py:168:14: E221 multiple spaces before operator
pymodbus/datastore/modredis.py:8:15: E702 multiple statements on one line (semicolon)
pymodbus/datastore/modredis.py:80:80: E501 line too long (80 characters)
pymodbus/datastore/modredis.py:82:80: E501 line too long (80 characters)
pymodbus/datastore/modredis.py:97:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:98:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:99:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:100:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:103:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:104:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:105:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:106:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:109:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:110:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:111:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:112:16: E203 whitespace before ':'
pymodbus/datastore/modredis.py:115:80: E501 line too long (80 characters)
pymodbus/datastore/modredis.py:117:80: E501 line too long (80 characters)
pymodbus/datastore/modredis.py:118:15: E221 multiple spaces before operator
pymodbus/datastore/modredis.py:132:16: E221 multiple spaces before operator
pymodbus/datastore/modredis.py:176:80: E501 line too long (92 characters)
pymodbus/datastore/modredis.py:176:14: E221 multiple spaces before operator
pymodbus/datastore/modredis.py:183:80: E501 line too long (80 characters)
pymodbus/datastore/modredis.py:185:80: E501 line too long (80 characters)
pymodbus/datastore/modredis.py:186:15: E221 multiple spaces before operator
pymodbus/datastore/modredis.py:201:16: E221 multiple spaces before operator
pymodbus/datastore/remote.py:98:32: E701 multiple statements on one line (colon)
pymodbus/datastore/remote.py:99:32: E701 multiple statements on one line (colon)
pymodbus/datastore/remote.py:100:13: E701 multiple statements on one line (colon)
pymodbus/datastore/store.py:144:13: E701 multiple statements on one line (colon)
pymodbus/datastore/store.py:163:15: E221 multiple spaces before operator
pymodbus/datastore/store.py:204:13: E701 multiple statements on one line (colon)
pymodbus/datastore/store.py:216:44: E225 missing whitespace around operator
pymodbus/datastore/store.py:225:22: E701 multiple statements on one line (colon)
4 E122 continuation line missing indentation or outdented
1 E125 continuation line does not distinguish itself from next logical line
77 E126 continuation line over-indented for hanging indent
4 E127 continuation line over-indented for visual indent
34 E128 continuation line under-indented for visual indent
1 E201 whitespace after '{'
1 E202 whitespace before '}'
68 E203 whitespace before ':'
154 E221 multiple spaces before operator
10 E225 missing whitespace around operator
29 E231 missing whitespace after ','
26 E261 at least two spaces before inline comment
10 E272 multiple spaces before keyword
47 E501 line too long (80 characters)
2 E502 the backslash is redundant between brackets
72 E701 multiple statements on one line (colon)
5 E702 multiple statements on one line (semicolon)
4 E711 comparison to None should be 'if cond is not None:'
pymodbus-1.3.2/doc/quality/current.lint 0000644 0001750 0001750 00000003536 13150360615 016331 0 ustar wmb wmb running lint
pymodbus/__init__.py:25: redefinition of unused 'NullHandler' from line 23
pymodbus/factory.py:12: 'from pymodbus.bit_read_message import *' used; unable to detect undefined names
pymodbus/factory.py:13: 'from pymodbus.bit_write_message import *' used; unable to detect undefined names
pymodbus/factory.py:14: 'from pymodbus.diag_message import *' used; unable to detect undefined names
pymodbus/factory.py:15: 'from pymodbus.file_message import *' used; unable to detect undefined names
pymodbus/factory.py:16: 'from pymodbus.other_message import *' used; unable to detect undefined names
pymodbus/factory.py:17: 'from pymodbus.register_read_message import *' used; unable to detect undefined names
pymodbus/factory.py:18: 'from pymodbus.register_write_message import *' used; unable to detect undefined names
pymodbus/server/async.py:230: local variable 'handle' is assigned to but never used
pymodbus/server/sync.py:16: 'from pymodbus.transaction import *' used; unable to detect undefined names
pymodbus/client/common.py:3: 'from pymodbus.bit_read_message import *' used; unable to detect undefined names
pymodbus/client/common.py:4: 'from pymodbus.bit_write_message import *' used; unable to detect undefined names
pymodbus/client/common.py:5: 'from pymodbus.register_read_message import *' used; unable to detect undefined names
pymodbus/client/common.py:6: 'from pymodbus.register_write_message import *' used; unable to detect undefined names
pymodbus/client/common.py:7: 'from pymodbus.diag_message import *' used; unable to detect undefined names
pymodbus/client/common.py:8: 'from pymodbus.file_message import *' used; unable to detect undefined names
pymodbus/client/common.py:9: 'from pymodbus.other_message import *' used; unable to detect undefined names
pymodbus/client/sync.py:8: 'from pymodbus.transaction import *' used; unable to detect undefined names
pymodbus-1.3.2/doc/TODO 0000644 0001750 0001750 00000003520 13150360615 012750 0 ustar wmb wmb ---------------------------------------------------------------------------
General
---------------------------------------------------------------------------
- reorganize code into folder namespaces
- put protocol code in protocol namespace
- make framer read header->read header.length
- maybe just for sync
- finish clients (and interface)
- add all modbus control into server
- add a frontend plugin system
- web frontend (bottle)
- twisted trial / twisted logging (for functional async tests)
- twisted serial server
- add daemonize code / init.d / config (or just use twisted)
- add correct transaction handling (retry, fail, etc)
- finish remaining functions
---------------------------------------------------------------------------
Protocols
---------------------------------------------------------------------------
- Serial RTU -> just use sleep wait
- Test serial against devices (and virtual tty)
---------------------------------------------------------------------------
Utilities
---------------------------------------------------------------------------
- (tcp/serial) forwarder
- (udp/serial) forwarder
---------------------------------------------------------------------------
Client
---------------------------------------------------------------------------
- Rework transaction flow and response data
---------------------------------------------------------------------------
Tools
---------------------------------------------------------------------------
- add functional tests
- add tk and wx gui frontdends (with editable data tables)
- rpm and deb packages (documentation)
---------------------------------------------------------------------------
Scratch
---------------------------------------------------------------------------
from twisted.python import log
observer = log.PythonLoggingObserver()
observer.start()
pymodbus-1.3.2/doc/api/ 0000755 0001750 0001750 00000000000 13150360615 013031 5 ustar wmb wmb pymodbus-1.3.2/doc/api/pydoc/ 0000755 0001750 0001750 00000000000 13150360615 014147 5 ustar wmb wmb pymodbus-1.3.2/doc/api/pydoc/build.py 0000644 0001750 0001750 00000036374 13150360615 015635 0 ustar wmb wmb #!/usr/bin/env python
"""
Pydoc sub-class for generating documentation for entire packages.
Taken from: http://pyopengl.sourceforge.net/pydoc/OpenGLContext.pydoc.pydoc2.html
Author: Mike Fletcher
"""
import logging
import pydoc, inspect, os, string, shutil
import sys, imp, os, stat, re, types, inspect
from repr import Repr
from string import expandtabs, find, join, lower, split, strip, rfind, rstrip
_log = logging.getLogger(__name__)
def classify_class_attrs(cls):
"""Return list of attribute-descriptor tuples.
For each name in dir(cls), the return list contains a 4-tuple
with these elements:
0. The name (a string).
1. The kind of attribute this is, one of these strings:
'class method' created via classmethod()
'static method' created via staticmethod()
'property' created via property()
'method' any other flavor of method
'data' not a method
2. The class which defined this attribute (a class).
3. The object as obtained directly from the defining class's
__dict__, not via getattr. This is especially important for
data attributes: C.data is just a data object, but
C.__dict__['data'] may be a data descriptor with additional
info, like a __doc__ string.
Note: This version is patched to work with Zope Interface-bearing objects
"""
mro = inspect.getmro(cls)
names = dir(cls)
result = []
for name in names:
# Get the object associated with the name.
# Getting an obj from the __dict__ sometimes reveals more than
# using getattr. Static and class methods are dramatic examples.
if name in cls.__dict__:
obj = cls.__dict__[name]
else:
try:
obj = getattr(cls, name)
except AttributeError, err:
continue
# Figure out where it was defined.
homecls = getattr(obj, "__objclass__", None)
if homecls is None:
# search the dicts.
for base in mro:
if name in base.__dict__:
homecls = base
break
# Get the object again, in order to get it from the defining
# __dict__ instead of via getattr (if possible).
if homecls is not None and name in homecls.__dict__:
obj = homecls.__dict__[name]
# Also get the object via getattr.
obj_via_getattr = getattr(cls, name)
# Classify the object.
if isinstance(obj, staticmethod):
kind = "static method"
elif isinstance(obj, classmethod):
kind = "class method"
elif isinstance(obj, property):
kind = "property"
elif (inspect.ismethod(obj_via_getattr) or
inspect.ismethoddescriptor(obj_via_getattr)):
kind = "method"
else:
kind = "data"
result.append((name, kind, homecls, obj))
return result
inspect.classify_class_attrs = classify_class_attrs
class DefaultFormatter(pydoc.HTMLDoc):
def docmodule(self, object, name=None, mod=None, packageContext = None, *ignored):
"""Produce HTML documentation for a module object."""
name = object.__name__ # ignore the passed-in name
parts = split(name, '.')
links = []
for i in range(len(parts)-1):
links.append(
'%s' %
(join(parts[:i+1], '.'), parts[i]))
linkedname = join(links + parts[-1:], '.')
head = '%s' % linkedname
try:
path = inspect.getabsfile(object)
url = path
if sys.platform == 'win32':
import nturl2path
url = nturl2path.pathname2url(path)
filelink = '%s' % (url, path)
except TypeError:
filelink = '(built-in)'
info = []
if hasattr(object, '__version__'):
version = str(object.__version__)
if version[:11] == '$' + 'Revision: ' and version[-1:] == '$':
version = strip(version[11:-1])
info.append('version %s' % self.escape(version))
if hasattr(object, '__date__'):
info.append(self.escape(str(object.__date__)))
if info:
head = head + ' (%s)' % join(info, ', ')
result = self.heading(
head, '#ffffff', '#7799ee', 'index
' + filelink)
modules = inspect.getmembers(object, inspect.ismodule)
classes, cdict = [], {}
for key, value in inspect.getmembers(object, inspect.isclass):
if (inspect.getmodule(value) or object) is object:
classes.append((key, value))
cdict[key] = cdict[value] = '#' + key
for key, value in classes:
for base in value.__bases__:
key, modname = base.__name__, base.__module__
module = sys.modules.get(modname)
if modname != name and module and hasattr(module, key):
if getattr(module, key) is base:
if not cdict.has_key(key):
cdict[key] = cdict[base] = modname + '.html#' + key
funcs, fdict = [], {}
for key, value in inspect.getmembers(object, inspect.isroutine):
if inspect.isbuiltin(value) or inspect.getmodule(value) is object:
funcs.append((key, value))
fdict[key] = '#-' + key
if inspect.isfunction(value): fdict[value] = fdict[key]
data = []
for key, value in inspect.getmembers(object, pydoc.isdata):
if key not in ['__builtins__', '__doc__']:
data.append((key, value))
doc = self.markup(pydoc.getdoc(object), self.preformat, fdict, cdict)
doc = doc and '%s' % doc
result = result + '%s
\n' % doc
packageContext.clean ( classes, object )
packageContext.clean ( funcs, object )
packageContext.clean ( data, object )
if hasattr(object, '__path__'):
modpkgs = []
modnames = []
for file in os.listdir(object.__path__[0]):
path = os.path.join(object.__path__[0], file)
modname = inspect.getmodulename(file)
if modname and modname not in modnames:
modpkgs.append((modname, name, 0, 0))
modnames.append(modname)
elif pydoc.ispackage(path):
modpkgs.append((file, name, 1, 0))
modpkgs.sort()
contents = self.multicolumn(modpkgs, self.modpkglink)
## result = result + self.bigsection(
## 'Package Contents', '#ffffff', '#aa55cc', contents)
result = result + self.moduleSection( object, packageContext)
elif modules:
contents = self.multicolumn(
modules, lambda (key, value), s=self: s.modulelink(value))
result = result + self.bigsection(
'Modules', '#fffff', '#aa55cc', contents)
if classes:
classlist = map(lambda (key, value): value, classes)
contents = [
self.formattree(inspect.getclasstree(classlist, 1), name)]
for key, value in classes:
contents.append(self.document(value, key, name, fdict, cdict))
result = result + self.bigsection(
'Classes', '#ffffff', '#ee77aa', join(contents))
if funcs:
contents = []
for key, value in funcs:
contents.append(self.document(value, key, name, fdict, cdict))
result = result + self.bigsection(
'Functions', '#ffffff', '#eeaa77', join(contents))
if data:
contents = []
for key, value in data:
try:
contents.append(self.document(value, key))
except Exception, err:
pass
result = result + self.bigsection(
'Data', '#ffffff', '#55aa55', join(contents, '
\n'))
if hasattr(object, '__author__'):
contents = self.markup(str(object.__author__), self.preformat)
result = result + self.bigsection(
'Author', '#ffffff', '#7799ee', contents)
if hasattr(object, '__credits__'):
contents = self.markup(str(object.__credits__), self.preformat)
result = result + self.bigsection(
'Credits', '#ffffff', '#7799ee', contents)
return result
def classlink(self, object, modname):
"""Make a link for a class."""
name, module = object.__name__, sys.modules.get(object.__module__)
if hasattr(module, name) and getattr(module, name) is object:
return '%s' % (
module.__name__, name, name
)
return pydoc.classname(object, modname)
def moduleSection( self, object, packageContext ):
"""Create a module-links section for the given object (module)"""
modules = inspect.getmembers(object, inspect.ismodule)
packageContext.clean ( modules, object )
packageContext.recurseScan( modules )
if hasattr(object, '__path__'):
modpkgs = []
modnames = []
for file in os.listdir(object.__path__[0]):
path = os.path.join(object.__path__[0], file)
modname = inspect.getmodulename(file)
if modname and modname not in modnames:
modpkgs.append((modname, object.__name__, 0, 0))
modnames.append(modname)
elif pydoc.ispackage(path):
modpkgs.append((file, object.__name__, 1, 0))
modpkgs.sort()
# do more recursion here...
for (modname, name, ya,yo) in modpkgs:
packageContext.addInteresting( join( (object.__name__, modname), '.'))
items = []
for (modname, name, ispackage,isshadowed) in modpkgs:
try:
# get the actual module object...
## if modname == "events":
## import pdb
## pdb.set_trace()
module = pydoc.safeimport( "%s.%s"%(name,modname) )
description, documentation = pydoc.splitdoc( inspect.getdoc( module ))
if description:
items.append(
"""%s -- %s"""% (
self.modpkglink( (modname, name, ispackage, isshadowed) ),
description,
)
)
else:
items.append(
self.modpkglink( (modname, name, ispackage, isshadowed) )
)
except:
items.append(
self.modpkglink( (modname, name, ispackage, isshadowed) )
)
contents = string.join( items, '
')
result = self.bigsection(
'Package Contents', '#ffffff', '#aa55cc', contents)
elif modules:
contents = self.multicolumn(
modules, lambda (key, value), s=self: s.modulelink(value))
result = self.bigsection(
'Modules', '#fffff', '#aa55cc', contents)
else:
result = ""
return result
class AlreadyDone(Exception):
pass
class PackageDocumentationGenerator:
"""A package document generator creates documentation
for an entire package using pydoc's machinery.
baseModules -- modules which will be included
and whose included and children modules will be
considered fair game for documentation
destinationDirectory -- the directory into which
the HTML documentation will be written
recursion -- whether to add modules which are
referenced by and/or children of base modules
exclusions -- a list of modules whose contents will
not be shown in any other module, commonly
such modules as OpenGL.GL, wxPython.wx etc.
recursionStops -- a list of modules which will
explicitly stop recursion (i.e. they will never
be included), even if they are children of base
modules.
formatter -- allows for passing in a custom formatter
see DefaultFormatter for sample implementation.
"""
def __init__ (
self, baseModules, destinationDirectory = ".",
recursion = 1, exclusions = (),
recursionStops = (),
formatter = None
):
self.destinationDirectory = os.path.abspath( destinationDirectory)
self.exclusions = {}
self.warnings = []
self.baseSpecifiers = {}
self.completed = {}
self.recursionStops = {}
self.recursion = recursion
for stop in recursionStops:
self.recursionStops[ stop ] = 1
self.pending = []
for exclusion in exclusions:
try:
self.exclusions[ exclusion ]= pydoc.locate ( exclusion)
except pydoc.ErrorDuringImport, value:
self.warn( """Unable to import the module %s which was specified as an exclusion module"""% (repr(exclusion)))
self.formatter = formatter or DefaultFormatter()
for base in baseModules:
self.addBase( base )
def warn( self, message ):
"""Warnings are used for recoverable, but not necessarily ignorable conditions"""
self.warnings.append (message)
def info (self, message):
"""Information/status report"""
_log.debug(message)
def addBase(self, specifier):
"""Set the base of the documentation set, only children of these modules will be documented"""
try:
self.baseSpecifiers [specifier] = pydoc.locate ( specifier)
self.pending.append (specifier)
except pydoc.ErrorDuringImport, value:
self.warn( """Unable to import the module %s which was specified as a base module"""% (repr(specifier)))
def addInteresting( self, specifier):
"""Add a module to the list of interesting modules"""
if self.checkScope( specifier):
self.pending.append (specifier)
else:
self.completed[ specifier] = 1
def checkScope (self, specifier):
"""Check that the specifier is "in scope" for the recursion"""
if not self.recursion:
return 0
items = string.split (specifier, ".")
stopCheck = items [:]
while stopCheck:
name = string.join(items, ".")
if self.recursionStops.get( name):
return 0
elif self.completed.get (name):
return 0
del stopCheck[-1]
while items:
if self.baseSpecifiers.get( string.join(items, ".")):
return 1
del items[-1]
# was not within any given scope
return 0
def process( self ):
"""Having added all of the base and/or interesting modules,
proceed to generate the appropriate documentation for each
module in the appropriate directory, doing the recursion
as we go."""
try:
while self.pending:
try:
if self.completed.has_key( self.pending[0] ):
raise AlreadyDone( self.pending[0] )
self.info( """Start %s"""% (repr(self.pending[0])))
object = pydoc.locate ( self.pending[0] )
self.info( """ ... found %s"""% (repr(object.__name__)))
except AlreadyDone:
pass
except pydoc.ErrorDuringImport, value:
self.info( """ ... FAILED %s"""% (repr( value)))
self.warn( """Unable to import the module %s"""% (repr(self.pending[0])))
except (SystemError, SystemExit), value:
self.info( """ ... FAILED %s"""% (repr( value)))
self.warn( """Unable to import the module %s"""% (repr(self.pending[0])))
except Exception, value:
self.info( """ ... FAILED %s"""% (repr( value)))
self.warn( """Unable to import the module %s"""% (repr(self.pending[0])))
else:
page = self.formatter.page(
pydoc.describe(object),
self.formatter.docmodule(
object,
object.__name__,
packageContext = self,
)
)
file = open (
os.path.join(
self.destinationDirectory,
self.pending[0] + ".html",
),
'w',
)
file.write(page)
file.close()
self.completed[ self.pending[0]] = object
del self.pending[0]
finally:
for item in self.warnings:
_log.info(item)
def clean (self, objectList, object):
"""callback from the formatter object asking us to remove
those items in the key, value pairs where the object is
imported from one of the excluded modules"""
for key, value in objectList[:]:
for excludeObject in self.exclusions.values():
if hasattr( excludeObject, key ) and excludeObject is not object:
if (
getattr( excludeObject, key) is value or
(hasattr( excludeObject, '__name__') and
excludeObject.__name__ == "Numeric"
)
):
objectList[:] = [ (k,o) for k,o in objectList if k != key ]
def recurseScan(self, objectList):
"""Process the list of modules trying to add each to the
list of interesting modules"""
for key, value in objectList:
self.addInteresting( value.__name__ )
#---------------------------------------------------------------------------#
# Main Runner
#---------------------------------------------------------------------------#
if __name__ == "__main__":
if not os.path.exists("./html"):
os.mkdir("./html")
print "Building Pydoc API Documentation"
PackageDocumentationGenerator(
baseModules = ['pymodbus', '__builtin__'],
destinationDirectory = "./html/",
exclusions = ['math', 'string', 'twisted'],
recursionStops = [],
).process ()
if os.path.exists('../../../build'):
shutil.move("html", "../../../build/pydoc")
pymodbus-1.3.2/doc/api/epydoc/ 0000755 0001750 0001750 00000000000 13150360615 014314 5 ustar wmb wmb pymodbus-1.3.2/doc/api/epydoc/build.py 0000755 0001750 0001750 00000001702 13150360615 015770 0 ustar wmb wmb #!/usr/bin/env python
'''
Epydoc API Runner
------------------
Using pkg_resources, we attempt to see if epydoc is installed,
if so, we use its cli program to compile the documents
'''
try:
import sys, os, shutil
import pkg_resources
pkg_resources.require("epydoc")
from epydoc.cli import cli
sys.argv = '''epydoc.py pymodbus
--html --simple-term --quiet
--include-log
--graph=all
--docformat=plaintext
--debug
--exclude=._
--exclude=tests
--output=html/
'''.split()
#bugs in trunk for --docformat=restructuredtext
if not os.path.exists("./html"):
os.mkdir("./html")
print "Building Epydoc API Documentation"
cli()
if os.path.exists('../../../build'):
shutil.move("html", "../../../build/epydoc")
except Exception, ex:
import traceback,sys
traceback.print_exc(file=sys.stdout)
print "Epydoc not avaliable...not building"
pymodbus-1.3.2/doc/api/pydoctor/ 0000755 0001750 0001750 00000000000 13150360615 014674 5 ustar wmb wmb pymodbus-1.3.2/doc/api/pydoctor/build.py 0000755 0001750 0001750 00000001440 13150360615 016347 0 ustar wmb wmb #!/usr/bin/env python
'''
Pydoctor API Runner
---------------------
Using pkg_resources, we attempt to see if pydoctor is installed,
if so, we use its cli program to compile the documents
'''
try:
import sys, os, shutil
import pkg_resources
pkg_resources.require("pydoctor")
from pydoctor.driver import main
sys.argv = '''pydoctor.py --quiet
--project-name=Pymodbus
--project-url=http://code.google.com/p/pymodbus/
--add-package=../../../pymodbus
--html-output=html
--html-write-function-pages --make-html'''.split()
print "Building Pydoctor API Documentation"
main(sys.argv[1:])
if os.path.exists('../../../build'):
shutil.move("html", "../../../build/pydoctor")
except: print "Pydoctor unavailable...not building"
pymodbus-1.3.2/doc/api/doxygen/ 0000755 0001750 0001750 00000000000 13150360615 014506 5 ustar wmb wmb pymodbus-1.3.2/doc/api/doxygen/build.py 0000644 0001750 0001750 00000002045 13150360615 016160 0 ustar wmb wmb #!/usr/bin/env python
'''
Doxygen API Builder
---------------------
'''
import os, shutil
def is_exe(path):
''' Returns if the program is executable
:param path: The path to the file
:return: True if it is, False otherwise
'''
return os.path.exists(path) and os.access(path, os.X_OK)
def which(program):
''' Check to see if an executable exists
:param program: The program to check for
:return: The full path of the executable or None if not found
'''
fpath, name = os.path.split(program)
if fpath:
if is_exe(program):
return program
else:
for path in os.environ["PATH"].split(os.pathsep):
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return exe_file
return None
if which('doxygen') is not None:
print "Building Doxygen API Documentation"
os.system("doxygen .doxygen")
if os.path.exists('../../../build'):
shutil.move("html", "../../../build/doxygen")
else: print "Doxygen not available...not building"
pymodbus-1.3.2/doc/api/doxygen/.doxygen 0000644 0001750 0001750 00000173714 13150360615 016201 0 ustar wmb wmb # Doxyfile 1.5.8
# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project
#
# All text after a hash (#) is considered a comment and will be ignored
# The format is:
# TAG = value [value, ...]
# For lists items can also be appended using:
# TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ")
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
# This tag specifies the encoding used for all characters in the config file
# that follow. The default is UTF-8 which is also the encoding used for all
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
# iconv built into libc) for the transcoding. See
# http://www.gnu.org/software/libiconv for the list of possible encodings.
DOXYFILE_ENCODING = UTF-8
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
# by quotes) that should identify the project.
PROJECT_NAME = Pymodbus
# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or
# if some version control system is used.
PROJECT_NUMBER = 0.5
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
# If a relative path is entered, it will be relative to the location
# where doxygen was started. If left blank the current directory will be used.
OUTPUT_DIRECTORY =
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
# 4096 sub-directories (in 2 levels) under the output directory of each output
# format and will distribute the generated files over these directories.
# Enabling this option can be useful when feeding doxygen a huge amount of
# source files, where putting all generated files in the same directory would
# otherwise cause performance problems for the file system.
CREATE_SUBDIRS = NO
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# The default language is English, other supported languages are:
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek,
# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages),
# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish,
# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene,
# Spanish, Swedish, and Ukrainian.
OUTPUT_LANGUAGE = English
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
# include brief member descriptions after the members that are listed in
# the file and class documentation (similar to JavaDoc).
# Set to NO to disable this.
BRIEF_MEMBER_DESC = YES
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
# the brief description of a member or function before the detailed description.
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.
REPEAT_BRIEF = YES
# This tag implements a quasi-intelligent brief description abbreviator
# that is used to form the text in various listings. Each string
# in this list, if found as the leading text of the brief description, will be
# stripped from the text and the result after processing the whole list, is
# used as the annotated text. Otherwise, the brief description is used as-is.
# If left blank, the following values are used ("$name" is automatically
# replaced with the name of the entity): "The $name class" "The $name widget"
# "The $name file" "is" "provides" "specifies" "contains"
# "represents" "a" "an" "the"
ABBREVIATE_BRIEF =
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# Doxygen will generate a detailed section even if there is only a brief
# description.
ALWAYS_DETAILED_SEC = NO
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
# inherited members of a class in the documentation of that class as if those
# members were ordinary class members. Constructors, destructors and assignment
# operators of the base classes will not be shown.
INLINE_INHERITED_MEMB = NO
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
# path before files name in the file list and in the header files. If set
# to NO the shortest path that makes the file name unique will be used.
FULL_PATH_NAMES = YES
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
# can be used to strip a user-defined part of the path. Stripping is
# only done if one of the specified strings matches the left-hand part of
# the path. The tag can be used to show relative paths in the file list.
# If left blank the directory from which doxygen is run is used as the
# path to strip.
STRIP_FROM_PATH =
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
# the path mentioned in the documentation of a class, which tells
# the reader which header file to include in order to use a class.
# If left blank only the name of the header file containing the class
# definition is used. Otherwise one should specify the include paths that
# are normally passed to the compiler using the -I flag.
STRIP_FROM_INC_PATH =
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
# (but less readable) file names. This can be useful is your file systems
# doesn't support long names like on DOS, Mac, or CD-ROM.
SHORT_NAMES = NO
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
# will interpret the first line (until the first dot) of a JavaDoc-style
# comment as the brief description. If set to NO, the JavaDoc
# comments will behave just like regular Qt-style comments
# (thus requiring an explicit @brief command for a brief description.)
JAVADOC_AUTOBRIEF = NO
# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
# interpret the first line (until the first dot) of a Qt-style
# comment as the brief description. If set to NO, the comments
# will behave just like regular Qt-style comments (thus requiring
# an explicit \brief command for a brief description.)
QT_AUTOBRIEF = NO
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
# comments) as a brief description. This used to be the default behaviour.
# The new default is to treat a multi-line C++ comment block as a detailed
# description. Set this tag to YES if you prefer the old behaviour instead.
MULTILINE_CPP_IS_BRIEF = NO
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# re-implements.
INHERIT_DOCS = YES
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
# a new page for each member. If set to NO, the documentation of a member will
# be part of the file/class/namespace that contains it.
SEPARATE_MEMBER_PAGES = NO
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
# Doxygen uses this value to replace tabs by spaces in code fragments.
TAB_SIZE = 4
# This tag can be used to specify a number of aliases that acts
# as commands in the documentation. An alias has the form "name=value".
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
# put the command \sideeffect (or @sideeffect) in the documentation, which
# will result in a user-defined paragraph with heading "Side Effects:".
# You can put \n's in the value part of an alias to insert newlines.
ALIASES =
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
# sources only. Doxygen will then generate output that is more tailored for C.
# For instance, some of the names that are used will be different. The list
# of all members will be omitted, etc.
OPTIMIZE_OUTPUT_FOR_C = NO
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
# sources only. Doxygen will then generate output that is more tailored for
# Java. For instance, namespaces will be presented as packages, qualified
# scopes will look different, etc.
OPTIMIZE_OUTPUT_JAVA = NO
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources only. Doxygen will then generate output that is more tailored for
# Fortran.
OPTIMIZE_FOR_FORTRAN = NO
# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
# sources. Doxygen will then generate output that is tailored for
# VHDL.
OPTIMIZE_OUTPUT_VHDL = NO
# Doxygen selects the parser to use depending on the extension of the files it parses.
# With this tag you can assign which parser to use for a given extension.
# Doxygen has a built-in mapping, but you can override or extend it using this tag.
# The format is ext=language, where ext is a file extension, and language is one of
# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP,
# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat
# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran),
# use: inc=Fortran f=C
EXTENSION_MAPPING =
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
# to include (a tag file for) the STL sources as input, then you should
# set this tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
# func(std::string) {}). This also make the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.
BUILTIN_STL_SUPPORT = NO
# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.
CPP_CLI_SUPPORT = NO
# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
# Doxygen will parse them like normal C++ but will assume all classes use public
# instead of private inheritance when no explicit protection keyword is present.
SIP_SUPPORT = NO
# For Microsoft's IDL there are propget and propput attributes to indicate getter
# and setter methods for a property. Setting this option to YES (the default)
# will make doxygen to replace the get and set methods by a property in the
# documentation. This will only work if the methods are indeed getting or
# setting a simple type. If this is not the case, or you want to show the
# methods anyway, you should set this option to NO.
IDL_PROPERTY_SUPPORT = YES
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.
DISTRIBUTE_GROUP_DOC = NO
# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
# the same type (for instance a group of public functions) to be put as a
# subgroup of that type (e.g. under the Public Functions section). Set it to
# NO to prevent subgrouping. Alternatively, this can be done per class using
# the \nosubgrouping command.
SUBGROUPING = YES
# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
# is documented as struct, union, or enum with the name of the typedef. So
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
# with name TypeT. When disabled the typedef will appear as a member of a file,
# namespace, or class. And the struct will be named TypeS. This can typically
# be useful for C code in case the coding convention dictates that all compound
# types are typedef'ed and only the typedef is referenced, never the tag name.
TYPEDEF_HIDES_STRUCT = NO
# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penality.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will rougly double the
# memory usage. The cache size is given by this formula:
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols
SYMBOL_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
# documentation are documented, even if no documentation was available.
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
EXTRACT_ALL = NO
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.
EXTRACT_PRIVATE = NO
# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.
EXTRACT_STATIC = NO
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
# defined locally in source files will be included in the documentation.
# If set to NO only classes defined in header files are included.
EXTRACT_LOCAL_CLASSES = YES
# This flag is only useful for Objective-C code. When set to YES local
# methods, which are defined in the implementation section but not in
# the interface are included in the documentation.
# If set to NO (the default) only methods in the interface are included.
EXTRACT_LOCAL_METHODS = NO
# If this flag is set to YES, the members of anonymous namespaces will be
# extracted and appear in the documentation as a namespace called
# 'anonymous_namespace{file}', where file will be replaced with the base
# name of the file that contains the anonymous namespace. By default
# anonymous namespace are hidden.
EXTRACT_ANON_NSPACES = NO
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
# undocumented members of documented classes, files or namespaces.
# If set to NO (the default) these members will be included in the
# various overviews, but no documentation section is generated.
# This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_MEMBERS = NO
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy.
# If set to NO (the default) these classes will be included in the various
# overviews. This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_CLASSES = NO
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
# friend (class|struct|union) declarations.
# If set to NO (the default) these declarations will be included in the
# documentation.
HIDE_FRIEND_COMPOUNDS = NO
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
# documentation blocks found inside the body of a function.
# If set to NO (the default) these blocks will be appended to the
# function's detailed documentation block.
HIDE_IN_BODY_DOCS = NO
# The INTERNAL_DOCS tag determines if documentation
# that is typed after a \internal command is included. If the tag is set
# to NO (the default) then the documentation will be excluded.
# Set it to YES to include the internal documentation.
INTERNAL_DOCS = NO
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
# file names in lower-case letters. If set to YES upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# and Mac users are advised to set this option to NO.
CASE_SENSE_NAMES = YES
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
# will show members with their full class and namespace scopes in the
# documentation. If set to YES the scope will be hidden.
HIDE_SCOPE_NAMES = NO
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
# will put a list of the files that are included by a file in the documentation
# of that file.
SHOW_INCLUDE_FILES = YES
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
# is inserted in the documentation for inline members.
INLINE_INFO = YES
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
# will sort the (detailed) documentation of file and class members
# alphabetically by member name. If set to NO the members will appear in
# declaration order.
SORT_MEMBER_DOCS = YES
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
# brief documentation of file, namespace and class members alphabetically
# by member name. If set to NO (the default) the members will appear in
# declaration order.
SORT_BRIEF_DOCS = NO
# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
# hierarchy of group names into alphabetical order. If set to NO (the default)
# the group names will appear in their defined order.
SORT_GROUP_NAMES = NO
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
# sorted by fully-qualified names, including namespaces. If set to
# NO (the default), the class list will be sorted only by class name,
# not including the namespace part.
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
# Note: This option applies only to the class list, not to the
# alphabetical list.
SORT_BY_SCOPE_NAME = NO
# The GENERATE_TODOLIST tag can be used to enable (YES) or
# disable (NO) the todo list. This list is created by putting \todo
# commands in the documentation.
GENERATE_TODOLIST = YES
# The GENERATE_TESTLIST tag can be used to enable (YES) or
# disable (NO) the test list. This list is created by putting \test
# commands in the documentation.
GENERATE_TESTLIST = YES
# The GENERATE_BUGLIST tag can be used to enable (YES) or
# disable (NO) the bug list. This list is created by putting \bug
# commands in the documentation.
GENERATE_BUGLIST = YES
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
# disable (NO) the deprecated list. This list is created by putting
# \deprecated commands in the documentation.
GENERATE_DEPRECATEDLIST= YES
# The ENABLED_SECTIONS tag can be used to enable conditional
# documentation sections, marked by \if sectionname ... \endif.
ENABLED_SECTIONS =
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
# the initial value of a variable or define consists of for it to appear in
# the documentation. If the initializer consists of more lines than specified
# here it will be hidden. Use a value of 0 to hide initializers completely.
# The appearance of the initializer of individual variables and defines in the
# documentation can be controlled using \showinitializer or \hideinitializer
# command in the documentation regardless of this setting.
MAX_INITIALIZER_LINES = 30
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
# at the bottom of the documentation of classes and structs. If set to YES the
# list will mention the files that were used to generate the documentation.
SHOW_USED_FILES = YES
# If the sources in your project are distributed over multiple directories
# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
# in the documentation. The default is NO.
SHOW_DIRECTORIES = NO
# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
# This will remove the Files entry from the Quick Index and from the
# Folder Tree View (if specified). The default is YES.
SHOW_FILES = YES
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
# Namespaces page.
# This will remove the Namespaces entry from the Quick Index
# and from the Folder Tree View (if specified). The default is YES.
SHOW_NAMESPACES = YES
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
# popen()) the command , where is the value of
# the FILE_VERSION_FILTER tag, and is the name of an input file
# provided by doxygen. Whatever the program writes to standard output
# is used as the file version. See the manual for examples.
FILE_VERSION_FILTER =
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by
# doxygen. The layout file controls the global structure of the generated output files
# in an output format independent way. The create the layout file that represents
# doxygen's defaults, run doxygen with the -l option. You can optionally specify a
# file name after the option, if omitted DoxygenLayout.xml will be used as the name
# of the layout file.
LAYOUT_FILE =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated
# by doxygen. Possible values are YES and NO. If left blank NO is used.
QUIET = YES
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated by doxygen. Possible values are YES and NO. If left blank
# NO is used.
WARNINGS = NO
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
# automatically be disabled.
WARN_IF_UNDOCUMENTED = NO
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some
# parameters in a documented function, or documenting parameters that
# don't exist or using markup commands wrongly.
WARN_IF_DOC_ERROR = NO
# This WARN_NO_PARAMDOC option can be abled to get warnings for
# functions that are documented, but have no documentation for their parameters
# or return value. If set to NO (the default) doxygen will only warn about
# wrong or incomplete parameter documentation, but not about the absence of
# documentation.
WARN_NO_PARAMDOC = NO
# The WARN_FORMAT tag determines the format of the warning messages that
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text. Optionally the format may contain
# $version, which will be replaced by the version of the file (if it could
# be obtained via FILE_VERSION_FILTER)
WARN_FORMAT = "$file:$line: $text"
# The WARN_LOGFILE tag can be used to specify a file to which warning
# and error messages should be written. If left blank the output is written
# to stderr.
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT = ../../../pymodbus
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
# also the default input encoding. Doxygen uses libiconv (or the iconv built
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
# the list of possible encodings.
INPUT_ENCODING = UTF-8
# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank the following patterns are tested:
# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
FILE_PATTERNS = *.py
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
# If left blank NO is used.
RECURSIVE = YES
# The EXCLUDE tag can be used to specify files and/or directories that should
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
EXCLUDE =
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
# directories that are symbolic links (a Unix filesystem feature) are excluded
# from the input.
EXCLUDE_SYMLINKS = NO
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*
EXCLUDE_PATTERNS =
# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test
EXCLUDE_SYMBOLS =
# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see
# the \include command).
EXAMPLE_PATH =
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.
EXAMPLE_PATTERNS =
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude
# commands irrespective of the value of the RECURSIVE tag.
# Possible values are YES and NO. If left blank NO is used.
EXAMPLE_RECURSIVE = NO
# The IMAGE_PATH tag can be used to specify one or more files or
# directories that contain image that are included in the documentation (see
# the \image command).
IMAGE_PATH =
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command , where
# is the value of the INPUT_FILTER tag, and is the name of an
# input file. Doxygen will then use the output that the filter program writes
# to standard output.
# If FILTER_PATTERNS is specified, this tag will be
# ignored.
INPUT_FILTER =
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis.
# Doxygen will compare the file name with each pattern and apply the
# filter if there is a match.
# The filters are a list of the form:
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
# is applied to all files.
FILTER_PATTERNS =
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will be used to filter the input files when producing source
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
FILTER_SOURCE_FILES = NO
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
# If the SOURCE_BROWSER tag is set to YES then a list of source files will
# be generated. Documented entities will be cross-referenced with these sources.
# Note: To get rid of all source code in the generated output, make sure also
# VERBATIM_HEADERS is set to NO.
SOURCE_BROWSER = NO
# Setting the INLINE_SOURCES tag to YES will include the body
# of functions and classes directly in the documentation.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
# doxygen to hide any special comment blocks from generated source code
# fragments. Normal C and C++ comments will always remain visible.
STRIP_CODE_COMMENTS = YES
# If the REFERENCED_BY_RELATION tag is set to YES
# then for each documented function all documented
# functions referencing it will be listed.
REFERENCED_BY_RELATION = YES
# If the REFERENCES_RELATION tag is set to YES
# then for each documented function all documented entities
# called/used by that function will be listed.
REFERENCES_RELATION = YES
# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
# link to the source code.
# Otherwise they will link to the documentation.
REFERENCES_LINK_SOURCE = YES
# If the USE_HTAGS tag is set to YES then the references to source code
# will point to the HTML generated by the htags(1) tool instead of doxygen
# built-in source browser. The htags tool is part of GNU's global source
# tagging system (see http://www.gnu.org/software/global/global.html). You
# will need version 4.8.6 or higher.
USE_HTAGS = NO
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
# will generate a verbatim copy of the header file for each class for
# which an include is specified. Set to NO to disable this.
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.
ALPHABETICAL_INDEX = NO
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])
COLS_IN_ALPHA_INDEX = 5
# In case all classes in a project start with a common prefix, all
# classes will be put under the same header in the alphabetical index.
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
# should be ignored while generating the index headers.
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
# generate HTML output.
GENERATE_HTML = YES
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `html' will be used as the default path.
HTML_OUTPUT = html
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
# doxygen will generate files with .html extension.
HTML_FILE_EXTENSION = .html
# The HTML_HEADER tag can be used to specify a personal HTML header for
# each generated HTML page. If it is left blank doxygen will generate a
# standard header.
HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
# each generated HTML page. If it is left blank doxygen will generate a
# standard footer.
HTML_FOOTER =
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
# style sheet that is used by each HTML page. It can be used to
# fine-tune the look of the HTML output. If the tag is left blank doxygen
# will generate a default style sheet. Note that doxygen will try to copy
# the style sheet file to the HTML output directory, so don't put your own
# stylesheet in the HTML output directory as well, or it will be erased!
HTML_STYLESHEET =
# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
# files or namespaces will be aligned in HTML using tables. If set to
# NO a bullet list will be used.
HTML_ALIGN_MEMBERS = YES
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded. For this to work a browser that supports
# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
HTML_DYNAMIC_SECTIONS = NO
# If the GENERATE_DOCSET tag is set to YES, additional index files
# will be generated that can be used as input for Apple's Xcode 3
# integrated development environment, introduced with OSX 10.5 (Leopard).
# To create a documentation set, doxygen will generate a Makefile in the
# HTML output directory. Running make will produce the docset in that
# directory and running "make install" will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
# it at startup.
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
GENERATE_DOCSET = NO
# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
# feed. A documentation feed provides an umbrella under which multiple
# documentation sets from a single provider (such as a company or product suite)
# can be grouped.
DOCSET_FEEDNAME = "Doxygen generated docs"
# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
# should uniquely identify the documentation set bundle. This should be a
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
# will append .docset to the name.
DOCSET_BUNDLE_ID = org.doxygen.Project
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
# of the generated HTML documentation.
GENERATE_HTMLHELP = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
# be used to specify the file name of the resulting .chm file. You
# can add a path in front of the file if the result should not be
# written to the html output directory.
CHM_FILE =
# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
# be used to specify the location (absolute path including file name) of
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
# the HTML help compiler on the generated index.hhp.
HHC_LOCATION =
# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
# controls if a separate .chi index file is generated (YES) or that
# it should be included in the master .chm file (NO).
GENERATE_CHI = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
# content.
CHM_INDEX_ENCODING =
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
# controls whether a binary table of contents is generated (YES) or a
# normal table of contents (NO) in the .chm file.
BINARY_TOC = NO
# The TOC_EXPAND flag can be set to YES to add extra items for group members
# to the contents of the HTML help documentation and to the tree view.
TOC_EXPAND = NO
# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER
# are set, an additional index file will be generated that can be used as input for
# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated
# HTML documentation.
GENERATE_QHP = NO
# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
# be used to specify the file name of the resulting .qch file.
# The path specified is relative to the HTML output folder.
QCH_FILE =
# The QHP_NAMESPACE tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#namespace
QHP_NAMESPACE =
# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#virtual-folders
QHP_VIRTUAL_FOLDER = doc
# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add.
# For more information please see
# http://doc.trolltech.com/qthelpproject.html#custom-filters
QHP_CUST_FILTER_NAME =
# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see
# Qt Help Project / Custom Filters.
QHP_CUST_FILTER_ATTRS =
# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's
# filter section matches.
# Qt Help Project / Filter Attributes.
QHP_SECT_FILTER_ATTRS =
# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
# be used to specify the location of Qt's qhelpgenerator.
# If non-empty doxygen will try to run qhelpgenerator on the generated
# .qhp file.
QHG_LOCATION =
# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
# top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it.
DISABLE_INDEX = NO
# This tag can be used to set the number of enum values (range [1..20])
# that doxygen will group on one line in the generated HTML documentation.
ENUM_VALUES_PER_LINE = 4
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information.
# If the tag value is set to FRAME, a side panel will be generated
# containing a tree-like index structure (just like the one that
# is generated for HTML Help). For this to work a browser that supports
# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
# probably better off using the HTML help feature. Other possible values
# for this tag are: HIERARCHIES, which will generate the Groups, Directories,
# and Class Hierarchy pages using a tree view instead of an ordered list;
# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which
# disables this behavior completely. For backwards compatibility with previous
# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE
# respectively.
GENERATE_TREEVIEW = NO
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
# used to set the initial width (in pixels) of the frame in which the tree
# is shown.
TREEVIEW_WIDTH = 250
# Use this tag to change the font size of Latex formulas included
# as images in the HTML documentation. The default is 10. Note that
# when you change the font size after a successful doxygen run you need
# to manually remove any form_*.png images from the HTML output directory
# to force them to be regenerated.
FORMULA_FONTSIZE = 10
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
# generate Latex output.
GENERATE_LATEX = NO
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `latex' will be used as the default path.
LATEX_OUTPUT = latex
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked. If left blank `latex' will be used as the default command name.
LATEX_CMD_NAME = latex
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
# generate index for LaTeX. If left blank `makeindex' will be used as the
# default command name.
MAKEINDEX_CMD_NAME = makeindex
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
# LaTeX documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_LATEX = NO
# The PAPER_TYPE tag can be used to set the paper type that is used
# by the printer. Possible values are: a4, a4wide, letter, legal and
# executive. If left blank a4wide will be used.
PAPER_TYPE = a4wide
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
# packages that should be included in the LaTeX output.
EXTRA_PACKAGES =
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
# the generated latex document. The header should contain everything until
# the first chapter. If it is left blank doxygen will generate a
# standard header. Notice: only use this tag if you know what you are doing!
LATEX_HEADER =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
# contain links (just like the HTML output) instead of page references
# This makes the output suitable for online browsing using a pdf viewer.
PDF_HYPERLINKS = NO
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
# plain latex in the generated Makefile. Set this option to YES to get a
# higher quality PDF documentation.
USE_PDFLATEX = NO
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
# command to the generated LaTeX files. This will instruct LaTeX to keep
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.
LATEX_BATCHMODE = NO
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
# include the index chapters (such as File Index, Compound Index, etc.)
# in the output.
LATEX_HIDE_INDICES = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
# The RTF output is optimized for Word 97 and may not look very pretty with
# other RTF readers or editors.
GENERATE_RTF = NO
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `rtf' will be used as the default path.
RTF_OUTPUT = rtf
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
# RTF documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_RTF = NO
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
# will contain hyperlink fields. The RTF file will
# contain links (just like the HTML output) instead of page references.
# This makes the output suitable for online browsing using WORD or other
# programs which support those fields.
# Note: wordpad (write) and others do not support links.
RTF_HYPERLINKS = NO
# Load stylesheet definitions from file. Syntax is similar to doxygen's
# config file, i.e. a series of assignments. You only have to provide
# replacements, missing definitions are set to their default value.
RTF_STYLESHEET_FILE =
# Set optional variables used in the generation of an rtf document.
# Syntax is similar to doxygen's config file.
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
# generate man pages
GENERATE_MAN = NO
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `man' will be used as the default path.
MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to
# the generated man pages (default is the subroutine's section .3)
MAN_EXTENSION = .3
# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
# then it will generate one additional man file for each entity
# documented in the real man page(s). These additional files
# only source the real man page, but without them the man command
# would be unable to find the correct page. The default is NO.
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
# If the GENERATE_XML tag is set to YES Doxygen will
# generate an XML file that captures the structure of
# the code including all documentation.
GENERATE_XML = NO
# The XML_OUTPUT tag is used to specify where the XML pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `xml' will be used as the default path.
XML_OUTPUT = xml
# The XML_SCHEMA tag can be used to specify an XML schema,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_SCHEMA =
# The XML_DTD tag can be used to specify an XML DTD,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_DTD =
# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
# dump the program listings (including syntax highlighting
# and cross-referencing information) to the XML output. Note that
# enabling this will significantly increase the size of the XML output.
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
# generate an AutoGen Definitions (see autogen.sf.net) file
# that captures the structure of the code including all
# documentation. Note that this feature is still experimental
# and incomplete at the moment.
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
# If the GENERATE_PERLMOD tag is set to YES Doxygen will
# generate a Perl module file that captures the structure of
# the code including all documentation. Note that this
# feature is still experimental and incomplete at the
# moment.
GENERATE_PERLMOD = NO
# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
# to generate PDF and DVI output from the Perl module output.
PERLMOD_LATEX = NO
# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
# nicely formatted so it can be parsed by a human reader.
# This is useful
# if you want to understand what is going on.
# On the other hand, if this
# tag is set to NO the size of the Perl module output will be much smaller
# and Perl will parse it just the same.
PERLMOD_PRETTY = YES
# The names of the make variables in the generated doxyrules.make file
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
# This is useful so different doxyrules.make files included by the same
# Makefile don't overwrite each other's variables.
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
# evaluate all C-preprocessor directives found in the sources and include
# files.
ENABLE_PREPROCESSING = YES
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
# names in the source code. If set to NO (the default) only conditional
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.
MACRO_EXPANSION = NO
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_DEFINED tags.
EXPAND_ONLY_PREDEF = NO
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# in the INCLUDE_PATH (see below) will be search if a #include is found.
SEARCH_INCLUDES = YES
# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by
# the preprocessor.
INCLUDE_PATH =
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will
# be used.
INCLUDE_FILE_PATTERNS =
# The PREDEFINED tag can be used to specify one or more macro names that
# are defined before the preprocessor is started (similar to the -D option of
# gcc). The argument of the tag is a list of macros of the form: name
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed. To prevent a macro definition from being
# undefined via #undef or recursively expanded use the := operator
# instead of the = operator.
PREDEFINED =
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition.
EXPAND_AS_DEFINED =
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all function-like macros that are alone
# on a line, have an all uppercase name, and do not end with a semicolon. Such
# function macros are typically used for boiler-plate code, and will confuse
# the parser if not removed.
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
# The TAGFILES option can be used to specify one or more tagfiles.
# Optionally an initial location of the external documentation
# can be added for each tagfile. The format of a tag file without
# this location is as follows:
#
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
#
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where "loc1" and "loc2" can be relative or absolute paths or
# URLs. If a location is present for each tag, the installdox tool
# does not have to be run to correct the links.
# Note that each tag file must have a unique name
# (where the name does NOT include the path)
# If a tag file is not located in the directory in which doxygen
# is run, you must also specify the path to the tagfile here.
TAGFILES =
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.
GENERATE_TAGFILE =
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
# in the class index. If set to NO only the inherited external classes
# will be listed.
ALLEXTERNALS = NO
# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will
# be listed.
EXTERNAL_GROUPS = YES
# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of `which perl').
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
# or super classes. Setting the tag to NO turns the diagrams off. Note that
# this option is superseded by the HAVE_DOT option below. This is only a
# fallback. It is recommended to install and use dot, since it yields more
# powerful graphs.
CLASS_DIAGRAMS = YES
# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.
MSCGEN_PATH =
# If set to YES, the inheritance and collaboration graphs will hide
# inheritance and usage relations if the target is undocumented
# or is not a class.
HIDE_UNDOC_RELATIONS = YES
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz, a graph visualization
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
# have no effect if this option is set to NO (the default)
HAVE_DOT = YES
# By default doxygen will write a font called FreeSans.ttf to the output
# directory and reference it in all dot files that doxygen generates. This
# font does not include all possible unicode characters however, so when you need
# these (or just want a differently looking font) you can specify the font name
# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
# which can be done by putting it in a standard location or by setting the
# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
# containing the font.
DOT_FONTNAME = FreeSans
# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
# The default size is 10pt.
DOT_FONTSIZE = 10
# By default doxygen will tell dot to use the output directory to look for the
# FreeSans.ttf font (which doxygen will put there itself). If you specify a
# different font using DOT_FONTNAME you can set the path where dot
# can find it using this tag.
DOT_FONTPATH =
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
# the CLASS_DIAGRAMS tag to NO.
CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect implementation dependencies (inheritance, containment, and
# class references variables) of the class with other documented classes.
COLLABORATION_GRAPH = YES
# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for groups, showing the direct groups dependencies
GROUP_GRAPHS = YES
# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.
UML_LOOK = NO
# If set to YES, the inheritance and collaboration graphs will show the
# relations between templates and their instances.
TEMPLATE_RELATIONS = NO
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
# tags are set to YES then doxygen will generate a graph for each documented
# file showing the direct and indirect include dependencies of the file with
# other documented files.
INCLUDE_GRAPH = YES
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
# documented header file showing the documented files that directly or
# indirectly include this file.
INCLUDED_BY_GRAPH = YES
# If the CALL_GRAPH and HAVE_DOT options are set to YES then
# doxygen will generate a call dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable call graphs
# for selected functions only using the \callgraph command.
CALL_GRAPH = NO
# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
# doxygen will generate a caller dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable caller
# graphs for selected functions only using the \callergraph command.
CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will graphical hierarchy of all classes instead of a textual one.
GRAPHICAL_HIERARCHY = YES
# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
# then doxygen will show the dependencies a directory has on other directories
# in a graphical way. The dependency relations are determined by the #include
# relations between the files in the directories.
DIRECTORY_GRAPH = YES
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. Possible values are png, jpg, or gif
# If left blank png will be used.
DOT_IMAGE_FORMAT = png
# The tag DOT_PATH can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.
DOT_PATH =
# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the
# \dotfile command).
DOTFILE_DIRS =
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# nodes that will be shown in the graph. If the number of nodes in a graph
# becomes larger than this value, doxygen will truncate the graph, which is
# visualized by representing a node as a red box. Note that doxygen if the
# number of direct children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
DOT_GRAPH_MAX_NODES = 50
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
# graphs generated by dot. A depth value of 3 means that only nodes reachable
# from the root by following a path via at most 3 edges will be shown. Nodes
# that lay further from the root node will be omitted. Note that setting this
# option to 1 or 2 may greatly reduce the computation time needed for large
# code bases. Also note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
MAX_DOT_GRAPH_DEPTH = 0
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. Warning: Depending on the platform used,
# enabling this option may lead to badly anti-aliased labels on the edges of
# a graph (i.e. they become hard to read).
DOT_TRANSPARENT = NO
# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10)
# support this, this feature is disabled by default.
DOT_MULTI_TARGETS = NO
# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
# generate a legend page explaining the meaning of the various boxes and
# arrows in the dot generated graphs.
GENERATE_LEGEND = YES
# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
# remove the intermediate dot files that are used to generate
# the various graphs.
DOT_CLEANUP = YES
#---------------------------------------------------------------------------
# Options related to the search engine
#---------------------------------------------------------------------------
# The SEARCHENGINE tag specifies whether or not a search engine should be
# used. If set to NO the values of all tags below this one will be ignored.
SEARCHENGINE = YES
pymodbus-1.3.2/doc/INSTALL 0000644 0001750 0001750 00000003122 13150360615 013307 0 ustar wmb wmb Requirements
-------------
* Python 2.3 or later.
* Python Twisted
* Pyserial
On Windows pywin32 is recommended (this is built in to ActivePython,
so no need to reinstall if you use it instead of standard Python):
http://sourceforge.net/project/showfiles.php?group_id=78018
The Windows IOCP reactor requires pywin32 build 205 or later.
Installation
-------------
To install the package from pypi, use either easy_install or pip::
pip install -U pymodbus
easy_install -U pymodbus
As with other Python packages, the standard way of installing from source
is (as root or administrator)::
python setup.py install
Running Tests
--------------
The tests can be run with the built in unittest module, however, it is
much easier to run with the nose package. With that installed, you can
use either of the following::
python setup.py test
nosetests
Building Documentation
----------------------
The documentation is written in restructured text using the sphinx module.
Building it is as simple as::
python setup build_sphinx
The API documents can be generated using one of four programs:
* epydoc
* pydoc
* pydoctor
* doxygen
To bulid these, simply run the following command and the available
packages will sipmly be built::
python setup.py build_apidocs
Quality Tests
----------------------
There are a number of quality tests that can be run against the code base
aside from unit tests::
python setup.py scan_2to3 # run a python3 compatability test
python setup.py pep8 # run a pop8 standards test
python setup.py lint # run a lint test
pymodbus-1.3.2/doc/LICENSE 0000644 0001750 0001750 00000002561 13150360615 013271 0 ustar wmb wmb Copyright (c) 2011 Galen Collins
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
pymodbus-1.3.2/doc/sphinx/ 0000755 0001750 0001750 00000000000 13150640232 013565 5 ustar wmb wmb pymodbus-1.3.2/doc/sphinx/examples/ 0000755 0001750 0001750 00000000000 13150640260 015404 5 ustar wmb wmb pymodbus-1.3.2/doc/sphinx/examples/bottle-frontend.rst 0000644 0001750 0001750 00000001314 13150360615 021246 0 ustar wmb wmb ==================================================
Bottle Web Frontend Example
==================================================
--------------------------------------------------
Summary
--------------------------------------------------
This is a simple example of adding a live REST api
on top of a running pymodbus server. This uses the
bottle microframework to achieve this.
The example can be hosted under twisted as well as
the bottle internal server and can furthermore be
run behind gunicorn, cherrypi, etc wsgi containers.
--------------------------------------------------
Main Program
--------------------------------------------------
.. literalinclude:: ../../../examples/gui/bottle/frontend.py
pymodbus-1.3.2/doc/sphinx/examples/redis-datastore.rst 0000644 0001750 0001750 00000000301 13150360615 021225 0 ustar wmb wmb ==================================================
Redis Datastore Example
==================================================
.. literalinclude:: ../../../examples/contrib/redis-datastore.py
pymodbus-1.3.2/doc/sphinx/examples/synchronous-server.rst 0000644 0001750 0001750 00000000306 13150360615 022036 0 ustar wmb wmb ==================================================
Synchronous Server Example
==================================================
.. literalinclude:: ../../../examples/common/synchronous-server.py
pymodbus-1.3.2/doc/sphinx/examples/database-datastore.rst 0000644 0001750 0001750 00000000307 13150360615 021671 0 ustar wmb wmb ==================================================
Database Datastore Example
==================================================
.. literalinclude:: ../../../examples/contrib/database-datastore.py
pymodbus-1.3.2/doc/sphinx/examples/wx-frontend.rst 0000644 0001750 0001750 00000001120 13150360615 020406 0 ustar wmb wmb ==================================================
WX Frontend Example
==================================================
Main Program
--------------------------------------------------
This is an example simulator that is written using the python wx
bindings. Although it currently does not have a frontend for
modifying the context values, it does allow one to expose N
virtual modbus devices to a network which is useful for testing
data center monitoring tools.
.. note:: The virtual networking code will only work on linux
.. literalinclude:: ../../../examples/gui/wx/simulator.py
pymodbus-1.3.2/doc/sphinx/examples/gtk-frontend.rst 0000644 0001750 0001750 00000001505 13150360615 020544 0 ustar wmb wmb ==================================================
Glade/GTK Frontend Example
==================================================
Main Program
--------------------------------------------------
This is an example simulator that is written using the pygtk
bindings. Although it currently does not have a frontend for
modifying the context values, it does allow one to expose N
virtual modbus devices to a network which is useful for testing
data center monitoring tools.
.. note:: The virtual networking code will only work on linux
.. literalinclude:: ../../../examples/gui/gtk/simulator.py
:language: python
Glade Layout File
--------------------------------------------------
The following is the glade layout file that is used by this script:
.. literalinclude:: ../../../examples/gui/gtk/simulator.glade
:language: xml
pymodbus-1.3.2/doc/sphinx/examples/asynchronous-server.rst 0000644 0001750 0001750 00000000310 13150360615 022172 0 ustar wmb wmb ==================================================
Asynchronous Server Example
==================================================
.. literalinclude:: ../../../examples/common/asynchronous-server.py
pymodbus-1.3.2/doc/sphinx/examples/serial-forwarder.rst 0000644 0001750 0001750 00000000307 13150360615 021411 0 ustar wmb wmb ==================================================
Synchronous Serial Forwarder
==================================================
.. literalinclude:: ../../../examples/contrib/serial-forwarder.py
pymodbus-1.3.2/doc/sphinx/examples/modbus-payload.rst 0000644 0001750 0001750 00000000320 13150360615 021054 0 ustar wmb wmb ==================================================
Modbus Payload Building/Decoding Example
==================================================
.. literalinclude:: ../../../examples/common/modbus-payload.py
pymodbus-1.3.2/doc/sphinx/examples/custom-datablock.rst 0000644 0001750 0001750 00000000302 13150360615 021370 0 ustar wmb wmb ==================================================
Custom Datablock Example
==================================================
.. literalinclude:: ../../../examples/common/custom-datablock.py
pymodbus-1.3.2/doc/sphinx/examples/libmodbus-client.rst 0000644 0001750 0001750 00000000302 13150360615 021370 0 ustar wmb wmb ==================================================
Libmodbus Client Facade
==================================================
.. literalinclude:: ../../../examples/contrib/libmodbus-client.py
pymodbus-1.3.2/doc/sphinx/examples/modbus-scraper.rst 0000644 0001750 0001750 00000000277 13150360615 021075 0 ustar wmb wmb ==================================================
Modbus Scraper Example
==================================================
.. literalinclude:: ../../../examples/contrib/modbus-scraper.py
pymodbus-1.3.2/doc/sphinx/examples/message-generator.rst 0000644 0001750 0001750 00000001474 13150360615 021557 0 ustar wmb wmb ==================================================
Modbus Message Generator Example
==================================================
This is an example of a utility that will build
examples of modbus messages in all the available
formats in the pymodbus package.
--------------------------------------------------
Program Source
--------------------------------------------------
.. literalinclude:: ../../../examples/contrib/message-generator.py
--------------------------------------------------
Example Request Messages
--------------------------------------------------
.. literalinclude:: ../../../examples/contrib/tx-messages
--------------------------------------------------
Example Response Messages
--------------------------------------------------
.. literalinclude:: ../../../examples/contrib/rx-messages
pymodbus-1.3.2/doc/sphinx/examples/remote-server-context.rst 0000644 0001750 0001750 00000000314 13150360615 022420 0 ustar wmb wmb ==================================================
Remote Single Server Context
==================================================
.. literalinclude:: ../../../examples/contrib/remote_server_context.py
pymodbus-1.3.2/doc/sphinx/examples/modbus-payload-server.rst 0000644 0001750 0001750 00000000335 13150360615 022366 0 ustar wmb wmb ==================================================
Modbus Payload Server Context Building Example
==================================================
.. literalinclude:: ../../../examples/common/modbus-payload-server.py
pymodbus-1.3.2/doc/sphinx/examples/index.rst 0000644 0001750 0001750 00000002123 13150360615 017246 0 ustar wmb wmb
Pymodbus Library Examples
====================================
*What follows is a collection of examples using the pymodbus
library in various ways*
Example Library Code
--------------------------------------------------
.. toctree::
:maxdepth: 2
asynchronous-client
asynchronous-server
asynchronous-processor
custom-message
custom-datablock
modbus-logging
modbus-payload
modbus-payload-server
synchronous-client
synchronous-client-ext
synchronous-server
performance
updating-server
callback-server
changing-framers
thread-safe-datastore
Custom Pymodbus Code
--------------------------------------------------
.. toctree::
:maxdepth: 2
redis-datastore
database-datastore
bcd-payload
modicon-payload
message-generator
message-parser
serial-forwarder
modbus-scraper
modbus-simulator
concurrent-client
libmodbus-client
remote-server-context
Example Frontend Code
--------------------------------------------------
.. toctree::
:maxdepth: 2
gtk-frontend
tk-frontend
wx-frontend
bottle-frontend
pymodbus-1.3.2/doc/sphinx/examples/modicon-payload.rst 0000644 0001750 0001750 00000000301 13150360615 021212 0 ustar wmb wmb ==================================================
Modicon Encoded Example
==================================================
.. literalinclude:: ../../../examples/contrib/modicon-payload.py
pymodbus-1.3.2/doc/sphinx/examples/thread-safe-datastore.rst 0000644 0001750 0001750 00000000315 13150360615 022307 0 ustar wmb wmb ==================================================
Thread Safe Datastore Example
==================================================
.. literalinclude:: ../../../examples/contrib/thread_safe_datastore.py
pymodbus-1.3.2/doc/sphinx/examples/updating-server.rst 0000644 0001750 0001750 00000000300 13150360615 021251 0 ustar wmb wmb ==================================================
Updating Server Example
==================================================
.. literalinclude:: ../../../examples/common/updating-server.py
pymodbus-1.3.2/doc/sphinx/examples/synchronous-client.rst 0000644 0001750 0001750 00000001570 13150360615 022012 0 ustar wmb wmb ==================================================
Synchronous Client Example
==================================================
It should be noted that each request will block waiting for the result. If asynchronous
behaviour is required, please use the asynchronous client implementations.
The synchronous client, works against TCP, UDP, serial ASCII, and serial RTU devices.
The synchronous client exposes the most popular methods of the modbus protocol,
however, if you want to execute other methods against the device,
simple create a request instance and pass it to the execute method.
Below an synchronous tcp client is demonstrated running against a
reference server. If you do not have a device to test with, feel free
to run a pymodbus server instance or start the reference tester in
the tools directory.
.. literalinclude:: ../../../examples/common/synchronous-client.py
pymodbus-1.3.2/doc/sphinx/examples/modbus-simulator.rst 0000644 0001750 0001750 00000000302 13150360615 021442 0 ustar wmb wmb ==================================================
Modbus Simulator Example
==================================================
.. literalinclude:: ../../../examples/contrib/modbus-simulator.py
pymodbus-1.3.2/doc/sphinx/examples/tk-frontend.rst 0000644 0001750 0001750 00000001117 13150360615 020374 0 ustar wmb wmb ==================================================
TK Frontend Example
==================================================
Main Program
--------------------------------------------------
This is an example simulator that is written using the native tk
toolkit. Although it currently does not have a frontend for
modifying the context values, it does allow one to expose N
virtual modbus devices to a network which is useful for testing
data center monitoring tools.
.. note:: The virtual networking code will only work on linux
.. literalinclude:: ../../../examples/gui/tk/simulator.py
pymodbus-1.3.2/doc/sphinx/examples/performance.rst 0000644 0001750 0001750 00000000710 13150360615 020440 0 ustar wmb wmb ==================================================
Synchronous Client Performance Check
==================================================
Below is a quick example of how to test the performance of a tcp modbus
device using the synchronous tcp client. If you do not have a device
to test with, feel free to run a pymodbus server instance or start
the reference tester in the tools directory.
.. literalinclude:: ../../../examples/common/performance.py
pymodbus-1.3.2/doc/sphinx/examples/synchronous-client-ext.rst 0000644 0001750 0001750 00000000323 13150360615 022603 0 ustar wmb wmb ==================================================
Synchronous Client Extended Example
==================================================
.. literalinclude:: ../../../examples/common/synchronous-client-ext.py
pymodbus-1.3.2/doc/sphinx/examples/asynchronous-processor.rst 0000644 0001750 0001750 00000001134 13150360615 022710 0 ustar wmb wmb ==================================================
Asynchronous Processor Example
==================================================
Below is a simplified asynchronous client skeleton that was
submitted by a user of the library. It can be used as a guide
for implementing more complex pollers or state machines.
Feel free to test it against whatever device you currently have
available. If you do not have a device to test with, feel free
to run a pymodbus server instance or start the reference tester in
the tools directory.
.. literalinclude:: ../../../examples/common/asynchronous-processor.py
pymodbus-1.3.2/doc/sphinx/examples/callback-server.rst 0000644 0001750 0001750 00000000300 13150360615 021172 0 ustar wmb wmb ==================================================
Callback Server Example
==================================================
.. literalinclude:: ../../../examples/common/callback-server.py
pymodbus-1.3.2/doc/sphinx/examples/modbus-logging.rst 0000644 0001750 0001750 00000000276 13150360615 021063 0 ustar wmb wmb ==================================================
Modbus Logging Example
==================================================
.. literalinclude:: ../../../examples/common/modbus-logging.py
pymodbus-1.3.2/doc/sphinx/examples/message-parser.rst 0000644 0001750 0001750 00000004354 13150360615 021065 0 ustar wmb wmb ==================================================
Modbus Message Parsing Example
==================================================
This is an example of a parser to decode raw messages
to a readable description. It will attempt to decode
a message to the request and response version of a
message if possible. Here is an example output::
$./message-parser.py -b -m 000112340006ff076d
================================================================================
Decoding Message 000112340006ff076d
================================================================================
ServerDecoder
--------------------------------------------------------------------------------
name = ReadExceptionStatusRequest
check = 0x0
unit_id = 0xff
transaction_id = 0x1
protocol_id = 0x1234
documentation =
This function code is used to read the contents of eight Exception Status
outputs in a remote device. The function provides a simple method for
accessing this information, because the Exception Output references are
known (no output reference is needed in the function).
ClientDecoder
--------------------------------------------------------------------------------
name = ReadExceptionStatusResponse
check = 0x0
status = 0x6d
unit_id = 0xff
transaction_id = 0x1
protocol_id = 0x1234
documentation =
The normal response contains the status of the eight Exception Status
outputs. The outputs are packed into one data byte, with one bit
per output. The status of the lowest output reference is contained
in the least significant bit of the byte. The contents of the eight
Exception Status outputs are device specific.
--------------------------------------------------
Program Source
--------------------------------------------------
.. literalinclude:: ../../../examples/contrib/message-parser.py
--------------------------------------------------
Example Messages
--------------------------------------------------
See the documentation for the message generator
for a collection of messages that can be parsed
by this utility.
pymodbus-1.3.2/doc/sphinx/examples/concurrent-client.rst 0000644 0001750 0001750 00000000314 13150360615 021575 0 ustar wmb wmb ==================================================
Modbus Concurrent Client Example
==================================================
.. literalinclude:: ../../../examples/contrib/concurrent-client.py
pymodbus-1.3.2/doc/sphinx/examples/changing-framers.rst 0000644 0001750 0001750 00000000302 13150360615 021347 0 ustar wmb wmb ==================================================
Changing Default Framers
==================================================
.. literalinclude:: ../../../examples/common/changing-framers.py
pymodbus-1.3.2/doc/sphinx/examples/bcd-payload.rst 0000644 0001750 0001750 00000000302 13150360615 020313 0 ustar wmb wmb ==================================================
Binary Coded Decimal Example
==================================================
.. literalinclude:: ../../../examples/contrib/bcd-payload.py
pymodbus-1.3.2/doc/sphinx/examples/asynchronous-client.rst 0000644 0001750 0001750 00000001267 13150360615 022156 0 ustar wmb wmb ==================================================
Asynchronous Client Example
==================================================
The asynchronous client functions in the same way as the synchronous
client, however, the asynchronous client uses twisted to return deferreds
for the response result. Just like the synchronous version, it works against
TCP, UDP, serial ASCII, and serial RTU devices.
Below an asynchronous tcp client is demonstrated running against a
reference server. If you do not have a device to test with, feel free
to run a pymodbus server instance or start the reference tester in
the tools directory.
.. literalinclude:: ../../../examples/common/asynchronous-client.py
pymodbus-1.3.2/doc/sphinx/examples/custom-message.rst 0000644 0001750 0001750 00000000276 13150360615 021102 0 ustar wmb wmb ==================================================
Custom Message Example
==================================================
.. literalinclude:: ../../../examples/common/custom-message.py
pymodbus-1.3.2/doc/sphinx/library/ 0000755 0001750 0001750 00000000000 13150360615 015235 5 ustar wmb wmb pymodbus-1.3.2/doc/sphinx/library/bit-write-message.rst 0000644 0001750 0001750 00000001123 13150360615 021314 0 ustar wmb wmb :mod:`bit_write_message` --- Bit Write Modbus Messages
============================================================
.. module:: bit_write_message
:synopsis: Bit Write Modbus Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.bit_write_message
.. autoclass:: WriteSingleCoilRequest
:members:
.. autoclass:: WriteSingleCoilResponse
:members:
.. autoclass:: WriteMultipleCoilsRequest
:members:
.. autoclass:: WriteMultipleCoilsResponse
:members:
pymodbus-1.3.2/doc/sphinx/library/constants.rst 0000644 0001750 0001750 00000001124 13150360615 020001 0 ustar wmb wmb :mod:`constants` --- Modbus Default Values
============================================================
.. module:: constants
:synopsis: Modbus Default Values
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.constants
.. autoclass:: Defaults
:members:
.. autoclass:: ModbusStatus
:members:
.. autoclass:: Endian
:members:
.. autoclass:: ModbusPlusOperation
:members:
.. autoclass:: DeviceInformation
:members:
.. autoclass:: MoreData
:members:
pymodbus-1.3.2/doc/sphinx/library/utilities.rst 0000644 0001750 0001750 00000001206 13150360615 020001 0 ustar wmb wmb :mod:`utilities` --- Extra Modbus Helpers
==========================================
.. module:: utilities
:synopsis: Extra Modbus Helpers
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.utilities
.. autofunction:: default
.. autofunction:: dict_property
.. autofunction:: pack_bitstring
.. autofunction:: unpack_bitstring
.. autofunction:: __generate_crc16_table
.. autofunction:: computeCRC
.. autofunction:: checkCRC
.. autofunction:: computeLRC
.. autofunction:: checkLRC
.. autofunction:: rtuFrameSize
pymodbus-1.3.2/doc/sphinx/library/pymodbus.rst 0000644 0001750 0001750 00000000350 13150360615 017627 0 ustar wmb wmb :mod:`pymodbus` --- Pymodbus Library
============================================================
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
.. automodule:: pymodbus
pymodbus-1.3.2/doc/sphinx/library/pdu.rst 0000644 0001750 0001750 00000001114 13150360615 016554 0 ustar wmb wmb :mod:`pdu` --- Base Structures
============================================================
.. module:: pdu
:synopsis: Base Structures
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.pdu
.. autoclass:: ModbusPDU
:members:
.. autoclass:: ModbusRequest
:members:
.. autoclass:: ModbusResponse
:members:
.. autoclass:: ModbusExceptions
:members:
.. autoclass:: ExceptionResponse
:members:
.. autoclass:: IllegalFunctionRequest
:members:
pymodbus-1.3.2/doc/sphinx/library/async-client.rst 0000644 0001750 0001750 00000000720 13150360615 020357 0 ustar wmb wmb :mod:`client.async` --- Twisted Async Modbus Client
====================================================
.. module:: client.async
:synopsis: Twisted Asynchronous Modbus Client
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
------------------
.. automodule:: pymodbus.client.async
.. autoclass:: ModbusClientProtocol
:members:
.. autoclass:: ModbusClientFactory
:members:
pymodbus-1.3.2/doc/sphinx/library/sync-client.rst 0000644 0001750 0001750 00000001055 13150360615 020220 0 ustar wmb wmb :mod:`client.sync` --- Twisted Synchronous Modbus Client
=========================================================
.. module:: client.sync
:synopsis: Twisted Synchronous Modbus Client
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
------------------
.. automodule:: pymodbus.client.sync
.. autoclass:: BaseModbusClient
:members:
.. autoclass:: ModbusTcpClient
:members:
.. autoclass:: ModbusUdpClient
:members:
.. autoclass:: ModbusSerialClient
:members:
pymodbus-1.3.2/doc/sphinx/library/other-message.rst 0000644 0001750 0001750 00000001255 13150360615 020535 0 ustar wmb wmb :mod:`other_message` --- Other Modbus Messages
============================================================
.. module:: other_message
:synopsis: Other Modbus Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.other_message
.. autoclass:: ReadExceptionStatusRequest
:members:
.. autoclass:: ReadExceptionStatusResponse
:members:
.. autoclass:: GetCommEventCounterRequest
:members:
.. autoclass:: GetCommEventCounterResponse
:members:
.. autoclass:: ReportSlaveIdRequest
:members:
.. autoclass:: ReportSlaveIdResponse
:members:
pymodbus-1.3.2/doc/sphinx/library/events.rst 0000644 0001750 0001750 00000001106 13150360615 017271 0 ustar wmb wmb :mod:`events` --- Events Used in PyModbus
============================================================
.. module:: events
:synopsis: Events Used in PyModbus
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.events
.. autoclass:: ModbusEvent
:members:
.. autoclass:: RemoteReceiveEvent
:members:
.. autoclass:: RemoteSendEvent
:members:
.. autoclass:: EnteredListenModeEvent
:members:
.. autoclass:: CommunicationRestartEvent
:members:
pymodbus-1.3.2/doc/sphinx/library/bit-read-message.rst 0000644 0001750 0001750 00000001245 13150360615 021102 0 ustar wmb wmb :mod:`bit_read_message` --- Bit Read Modbus Messages
============================================================
.. module:: bit_read_message
:synopsis: Bit Read Modbus Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.bit_read_message
.. autoclass:: ReadBitsRequestBase
:members:
.. autoclass:: ReadBitsResponseBase
:members:
.. autoclass:: ReadCoilsRequest
:members:
.. autoclass:: ReadCoilsResponse
:members:
.. autoclass:: ReadDiscreteInputsRequest
:members:
.. autoclass:: ReadDiscreteInputsResponse
:members:
pymodbus-1.3.2/doc/sphinx/library/file-message.rst 0000644 0001750 0001750 00000001276 13150360615 020336 0 ustar wmb wmb :mod:`file_message` --- File Modbus Messages
============================================================
.. module:: file_message
:synopsis: File Modbus Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.file_message
.. autoclass:: FileRecord
:members:
.. autoclass:: ReadFileRecordRequest
:members:
.. autoclass:: ReadFileRecordResponse
:members:
.. autoclass:: WriteFileRecordRequest
:members:
.. autoclass:: WriteFileRecordResponse
:members:
.. autoclass:: ReadFifoQueueRequest
:members:
.. autoclass:: ReadFifoQueueResponse
:members:
pymodbus-1.3.2/doc/sphinx/library/datastore/ 0000755 0001750 0001750 00000000000 13150360615 017223 5 ustar wmb wmb pymodbus-1.3.2/doc/sphinx/library/datastore/index.rst 0000644 0001750 0001750 00000000333 13150360615 021063 0 ustar wmb wmb
Server Datastores and Contexts
====================================
*The following are the API documentation strings taken
from the sourcecode*
.. toctree::
:maxdepth: 2
store.rst
context.rst
remote.rst
pymodbus-1.3.2/doc/sphinx/library/datastore/store.rst 0000644 0001750 0001750 00000001020 13150360615 021102 0 ustar wmb wmb :mod:`store` --- Datastore for Modbus Server Context
============================================================
.. module:: store
:synopsis: Datastore for Modbus Server Context
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.datastore.store
.. autoclass:: BaseModbusDataBlock
:members:
.. autoclass:: ModbusSequentialDataBlock
:members:
.. autoclass:: ModbusSparseDataBlock
:members:
pymodbus-1.3.2/doc/sphinx/library/datastore/remote.rst 0000644 0001750 0001750 00000000611 13150360615 021246 0 ustar wmb wmb :mod:`remote` --- Remote Slave Context
============================================================
.. module:: remote
:synopsis: Remote Slave Context
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.datastore.remote
.. autoclass:: RemoteSlaveContext
:members:
pymodbus-1.3.2/doc/sphinx/library/datastore/context.rst 0000644 0001750 0001750 00000000702 13150360615 021440 0 ustar wmb wmb :mod:`context` --- Modbus Server Contexts
============================================================
.. module:: context
:synopsis: Modbus Server Contexts
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.datastore.context
.. autoclass:: ModbusSlaveContext
:members:
.. autoclass:: ModbusServerContext
:members:
pymodbus-1.3.2/doc/sphinx/library/client-common.rst 0000644 0001750 0001750 00000000627 13150360615 020540 0 ustar wmb wmb :mod:`client.common` --- Twisted Async Modbus Client
====================================================
.. module:: client.common
:synopsis: Modbus common client clode
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
------------------
.. automodule:: pymodbus.client.common
.. autoclass:: ModbusClientMixin
:members:
pymodbus-1.3.2/doc/sphinx/library/index.rst 0000644 0001750 0001750 00000001231 13150360615 017073 0 ustar wmb wmb
Pymodbus Library API Documentation
====================================
*The following are the API documentation strings taken
from the sourcecode*
.. toctree::
:maxdepth: 2
bit-read-message.rst
bit-write-message.rst
client-common.rst
sync-client.rst
async-client.rst
constants.rst
datastore/index.rst
diag-message.rst
device.rst
factory.rst
interfaces.rst
exceptions.rst
other-message.rst
mei-message.rst
file-message.rst
events.rst
payload.rst
pdu.rst
pymodbus.rst
register-read-message.rst
register-write-message.rst
sync-server.rst
async-server.rst
transaction.rst
utilities.rst
pymodbus-1.3.2/doc/sphinx/library/sync-server.rst 0000644 0001750 0001750 00000001522 13150360615 020247 0 ustar wmb wmb :mod:`server.sync` --- Twisted Synchronous Modbus Server
============================================================
.. module:: server.sync
:synopsis: Twisted Synchronous Modbus Server
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.server.sync
.. autoclass:: ModbusBaseRequestHandler
:members:
.. autoclass:: ModbusSingleRequestHandler
:members:
.. autoclass:: ModbusConnectedRequestHandler
:members:
.. autoclass:: ModbusDisconnectedRequestHandler
:members:
.. autoclass:: ModbusTcpServer
:members:
.. autoclass:: ModbusUdpServer
:members:
.. autoclass:: ModbusSerialServer
:members:
.. autofunction:: StartTcpServer
.. autofunction:: StartUdpServer
.. autofunction:: StartSerialServer
pymodbus-1.3.2/doc/sphinx/library/register-read-message.rst 0000644 0001750 0001750 00000001517 13150360615 022152 0 ustar wmb wmb :mod:`register_read_message` --- Register Read Messages
============================================================
.. module:: register_read_message
:synopsis: Register Read Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.register_read_message
.. autoclass:: ReadRegistersRequestBase
:members:
.. autoclass:: ReadRegistersResponseBase
:members:
.. autoclass:: ReadHoldingRegistersRequest
:members:
.. autoclass:: ReadHoldingRegistersResponse
:members:
.. autoclass:: ReadInputRegistersRequest
:members:
.. autoclass:: ReadInputRegistersResponse
:members:
.. autoclass:: ReadWriteMultipleRegistersRequest
:members:
.. autoclass:: ReadWriteMultipleRegistersResponse
:members:
pymodbus-1.3.2/doc/sphinx/library/transaction.rst 0000644 0001750 0001750 00000001242 13150360615 020313 0 ustar wmb wmb :mod:`transaction` --- Transaction Controllers for Pymodbus
============================================================
.. module:: transaction
:synopsis: Transaction controllers for pymodbus
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.transaction
.. autoclass:: DictTransactionManager
:members:
.. autoclass:: FifoTransactionManager
:members:
.. autoclass:: ModbusSocketFramer
:members:
.. autoclass:: ModbusRtuFramer
:members:
.. autoclass:: ModbusAsciiFramer
:members:
.. autoclass:: ModbusBinaryFramer
:members:
pymodbus-1.3.2/doc/sphinx/library/diag-message.rst 0000644 0001750 0001750 00000005110 13150360615 020312 0 ustar wmb wmb :mod:`diag_message` --- Diagnostic Modbus Messages
============================================================
.. module:: diag_message
:synopsis: Diagnostic Modbus Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.diag_message
.. autoclass:: DiagnosticStatusRequest
:members:
.. autoclass:: DiagnosticStatusResponse
:members:
.. autoclass:: DiagnosticStatusSimpleRequest
:members:
.. autoclass:: DiagnosticStatusSimpleResponse
:members:
.. autoclass:: ReturnQueryDataRequest
:members:
.. autoclass:: ReturnQueryDataResponse
:members:
.. autoclass:: RestartCommunicationsOptionRequest
:members:
.. autoclass:: RestartCommunicationsOptionResponse
:members:
.. autoclass:: ReturnDiagnosticRegisterRequest
:members:
.. autoclass:: ReturnDiagnosticRegisterResponse
:members:
.. autoclass:: ChangeAsciiInputDelimiterRequest
:members:
.. autoclass:: ChangeAsciiInputDelimiterResponse
:members:
.. autoclass:: ForceListenOnlyModeRequest
:members:
.. autoclass:: ForceListenOnlyModeResponse
:members:
.. autoclass:: ClearCountersRequest
:members:
.. autoclass:: ClearCountersResponse
:members:
.. autoclass:: ReturnBusMessageCountRequest
:members:
.. autoclass:: ReturnBusMessageCountResponse
:members:
.. autoclass:: ReturnBusCommunicationErrorCountRequest
:members:
.. autoclass:: ReturnBusCommunicationErrorCountResponse
:members:
.. autoclass:: ReturnBusExceptionErrorCountRequest
:members:
.. autoclass:: ReturnBusExceptionErrorCountResponse
:members:
.. autoclass:: ReturnSlaveMessageCountRequest
:members:
.. autoclass:: ReturnSlaveMessageCountResponse
:members:
.. autoclass:: ReturnSlaveNoResponseCountRequest
:members:
.. autoclass:: ReturnSlaveNoReponseCountResponse
:members:
.. autoclass:: ReturnSlaveNAKCountRequest
:members:
.. autoclass:: ReturnSlaveNAKCountResponse
:members:
.. autoclass:: ReturnSlaveBusyCountRequest
:members:
.. autoclass:: ReturnSlaveBusyCountResponse
:members:
.. autoclass:: ReturnSlaveBusCharacterOverrunCountRequest
:members:
.. autoclass:: ReturnSlaveBusCharacterOverrunCountResponse
:members:
.. autoclass:: ReturnIopOverrunCountRequest
:members:
.. autoclass:: ReturnIopOverrunCountResponse
:members:
.. autoclass:: ClearOverrunCountRequest
:members:
.. autoclass:: ClearOverrunCountResponse
:members:
.. autoclass:: GetClearModbusPlusRequest
:members:
.. autoclass:: GetClearModbusPlusResponse
:members:
pymodbus-1.3.2/doc/sphinx/library/register-write-message.rst 0000644 0001750 0001750 00000001156 13150360615 022370 0 ustar wmb wmb :mod:`register_write_message` --- Register Write Messages
============================================================
.. module:: register_write_message
:synopsis: Register Write Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.register_write_message
.. autoclass:: WriteSingleRegisterRequest
:members:
.. autoclass:: WriteSingleRegisterResponse
:members:
.. autoclass:: WriteMultipleRegistersRequest
:members:
.. autoclass:: WriteMultipleRegistersResponse
:members:
pymodbus-1.3.2/doc/sphinx/library/payload.rst 0000644 0001750 0001750 00000000676 13150360615 017431 0 ustar wmb wmb :mod:`payload` --- Modbus Payload Utilities
============================================================
.. module:: payload
:synopsis: Modbus Payload Utilities
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.payload
.. autoclass:: BinaryPayloadBuilder
:members:
.. autoclass:: BinaryPayloadDecoder
:members:
pymodbus-1.3.2/doc/sphinx/library/async-server.rst 0000644 0001750 0001750 00000001166 13150360615 020414 0 ustar wmb wmb :mod:`server.async` --- Twisted Asynchronous Modbus Server
============================================================
.. module:: server.async
:synopsis: Twisted Asynchronous Modbus Server
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.server.async
.. autoclass:: ModbusTcpProtocol
:members:
.. autoclass:: ModbusUdpProtocol
:members:
.. autoclass:: ModbusServerFactory
:members:
.. autofunction:: StartTcpServer
.. autofunction:: StartUdpServer
.. autofunction:: StartSerialServer
pymodbus-1.3.2/doc/sphinx/library/interfaces.rst 0000644 0001750 0001750 00000001061 13150360615 020110 0 ustar wmb wmb :mod:`interfaces` --- System Interfaces
============================================================
.. module:: interfaces
:synopsis: System Interfaces
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.interfaces
.. autoclass:: Singleton
:members:
.. autoclass:: IModbusDecoder
:members:
.. autoclass:: IModbusFramer
:members:
.. autoclass:: IModbusSlaveContext
:members:
.. autoclass:: IPayloadBuilder
:members:
pymodbus-1.3.2/doc/sphinx/library/factory.rst 0000644 0001750 0001750 00000000662 13150360615 017442 0 ustar wmb wmb :mod:`factory` --- Request/Response Decoders
============================================================
.. module:: factory
:synopsis: Request/Response Decoders
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.factory
.. autoclass:: ServerDecoder
:members:
.. autoclass:: ClientDecoder
:members:
pymodbus-1.3.2/doc/sphinx/library/device.rst 0000644 0001750 0001750 00000001140 13150360615 017222 0 ustar wmb wmb :mod:`device` --- Modbus Device Representation
============================================================
.. module:: device
:synopsis: Modbus Device Representation
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.device
.. autoclass:: ModbusAccessControl
:members:
.. autoclass:: ModbusPlusStatistics
:members:
.. autoclass:: ModbusDeviceIdentification
:members:
.. autoclass:: DeviceInformationFactory
:members:
.. autoclass:: ModbusControlBlock
:members:
pymodbus-1.3.2/doc/sphinx/library/exceptions.rst 0000644 0001750 0001750 00000001053 13150360615 020147 0 ustar wmb wmb :mod:`exceptions` --- Exceptions Used in PyModbus
============================================================
.. module:: exceptions
:synopsis: Exceptions Used in PyModbus
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.exceptions
.. autoclass:: ModbusException
:members:
.. autoclass:: ModbusIOException
:members:
.. autoclass:: ParameterException
:members:
.. autoclass:: NotImplementedException
:members:
pymodbus-1.3.2/doc/sphinx/library/mei-message.rst 0000644 0001750 0001750 00000000721 13150360615 020163 0 ustar wmb wmb :mod:`mei_message` --- MEI Modbus Messages
============================================================
.. module:: mei_message
:synopsis: MEI Modbus Messages
.. moduleauthor:: Galen Collins
.. sectionauthor:: Galen Collins
API Documentation
-------------------
.. automodule:: pymodbus.mei_message
.. autoclass:: ReadDeviceInformationRequest
:members:
.. autoclass:: ReadDeviceInformationResponse
:members:
pymodbus-1.3.2/doc/sphinx/index.rst 0000644 0001750 0001750 00000000727 13150360615 015440 0 ustar wmb wmb .. PyModbus documentation master file, created by
sphinx-quickstart on Tue Apr 14 19:11:16 2009.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
Welcome to PyModbus's documentation!
====================================
Contents:
.. toctree::
:maxdepth: 2
examples/index.rst
library/index.rst
Indices and tables
==================
* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`
pymodbus-1.3.2/doc/sphinx/Makefile 0000644 0001750 0001750 00000005637 13150360615 015244 0 ustar wmb wmb # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help clean html dirhtml pickle json htmlhelp qthelp latex changes linkcheck doctest
help:
@echo "Please use \`make ' where is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
clean:
-rm -rf build/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) build/html
@echo
@echo "Build finished. The HTML pages are in build/html."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) build/dirhtml
@echo
@echo "Build finished. The HTML pages are in build/dirhtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) build/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) build/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) build/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in build/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) build/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in build/qthelp, like this:"
@echo "# qcollectiongenerator build/qthelp/PyModbus.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile build/qthelp/PyModbus.qhc"
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) build/latex
@echo
@echo "Build finished; the LaTeX files are in build/latex."
@echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \
"run these through (pdf)latex."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) build/changes
@echo
@echo "The overview file is in build/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) build/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in build/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) build/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in build/doctest/output.txt."
pymodbus-1.3.2/doc/sphinx/static/ 0000755 0001750 0001750 00000000000 13150360615 015060 5 ustar wmb wmb pymodbus-1.3.2/doc/sphinx/static/README 0000644 0001750 0001750 00000000045 13150360615 015737 0 ustar wmb wmb include any html static content here
pymodbus-1.3.2/doc/sphinx/conf.py 0000644 0001750 0001750 00000007137 13150360615 015100 0 ustar wmb wmb # -*- coding: utf-8 -*-
#
# pymodbus documentation build configuration file, created by
# sphinx-quickstart on Fri May 26 10:10:53 2017.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
sys.path.insert(0, os.path.abspath(os.pardir))
from pymodbus import __version__, __author__, __maintainer__
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
# Sphinx extension module names.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.intersphinx',
'sphinx.ext.viewcode',
'humanfriendly.sphinx',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# Sort members by the source order instead of alphabetically.
autodoc_member_order = 'bysource'
# Paths that contain templates, relative to this directory.
templates_path = ['templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'pymodbus'
copyright = u'2017, {}, {}'.format(__author__, __maintainer__)
author = u'{}, {}'.format(__author__, __maintainer__)
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = __version__
# The full version, including alpha/beta/rc tags.
release = __version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = 'en'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['build', '_build', 'Thumbs.db', '.DS_Store']
# If true, '()' will be appended to :func: etc. cross-reference text.
add_function_parentheses = True
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# Refer to the Python standard library.
# From: http://twistedmatrix.com/trac/ticket/4582.
intersphinx_mapping = dict(
python=('https://docs.python.org/2', None),
capturer=('https://capturer.readthedocs.io/en/latest', None),
humanfriendly=('https://humanfriendly.readthedocs.io/en/latest', None),
)
# -- Options for HTML output --------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'default'
# Output file base name for HTML help builder.
htmlhelp_basename = 'pymodbusdoc'
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['static']
pymodbus-1.3.2/Makefile 0000644 0001750 0001750 00000003552 13150360615 013160 0 ustar wmb wmb # Makefile for the `pymodbus' package.
WORKON_HOME ?= $(HOME)/.virtualenvs
VIRTUAL_ENV ?= $(WORKON_HOME)/pymodbus
PATH := $(VIRTUAL_ENV)/bin:$(PATH)
MAKE := $(MAKE) --no-print-directory
SHELL = bash
default:
@echo 'Makefile for pymodbus'
@echo
@echo 'Usage:'
@echo
@echo ' make install install the package in a virtual environment'
@echo ' make reset recreate the virtual environment'
@echo ' make check check coding style (PEP-8, PEP-257)'
@echo ' make test run the test suite, report coverage'
@echo ' make tox run the tests on all Python versions'
@echo ' make clean cleanup all temporary files'
@echo
install:
@test -d "$(VIRTUAL_ENV)" || mkdir -p "$(VIRTUAL_ENV)"
@test -x "$(VIRTUAL_ENV)/bin/python" || virtualenv --quiet "$(VIRTUAL_ENV)"
@test -x "$(VIRTUAL_ENV)/bin/pip" || easy_install pip
@pip install --quiet --requirement=requirements.txt
@pip uninstall --yes pymodbus &>/dev/null || true
@pip install --quiet --no-deps --ignore-installed .
reset:
$(MAKE) clean
rm -Rf "$(VIRTUAL_ENV)"
$(MAKE) install
check: install
@pip install --upgrade --quiet --requirement=requirements-checks.txt
@flake8
test: install
@pip install --quiet --requirement=requirements-tests.txt
@nosetests --with-coverage --cover-html
@coverage report --fail-under=90
tox: install
@pip install --quiet tox && tox
docs: install
@pip install --quiet sphinx
@cd doc/sphinx && sphinx-build -nb html -d doctrees . html
publish: install
git push origin && git push --tags origin
$(MAKE) clean
pip install --quiet twine wheel
python setup.py sdist bdist_wheel
twine upload dist/*
$(MAKE) clean
clean:
@rm -Rf *.egg .cache .coverage .tox build dist docs/build htmlcov
@find -depth -type d -name __pycache__ -exec rm -Rf {} \;
@find -type f -name '*.pyc' -delete
.PHONY: default install reset check test tox docs publish clean
pymodbus-1.3.2/scripts/ 0000755 0001750 0001750 00000000000 13150360615 013202 5 ustar wmb wmb pymodbus-1.3.2/scripts/travis.sh 0000755 0001750 0001750 00000000346 13150360615 015054 0 ustar wmb wmb #!/bin/bash -e
if [ "$TRAVIS_OS_NAME" = osx ]; then
VIRTUAL_ENV="$HOME/.virtualenvs/python2.7"
if [ ! -x "$VIRTUAL_ENV/bin/python" ]; then
virtualenv "$VIRTUAL_ENV"
fi
source "$VIRTUAL_ENV/bin/activate"
fi
eval "$@"
pymodbus-1.3.2/.travis.yml 0000644 0001750 0001750 00000001424 13150360615 013625 0 ustar wmb wmb sudo: false
language: python
matrix:
include:
- os: linux
python: "2.7"
- os: linux
python: "3.4"
- os: linux
python: "3.5"
- os: linux
python: "3.6"
- os: osx
language: generic
before_install:
- if [ $TRAVIS_OS_NAME = osx ]; then brew update; fi
- if [ $TRAVIS_OS_NAME = osx ]; then brew install openssl; fi
install:
# - scripts/travis.sh pip install pip-accel
- scripts/travis.sh pip install coveralls
- scripts/travis.sh pip install --requirement=requirements-checks.txt
- scripts/travis.sh pip install --requirement=requirements-tests.txt
- scripts/travis.sh LC_ALL=C pip install .
script:
# - scripts/travis.sh make check
- scripts/travis.sh make test
after_success:
- scripts/travis.sh coveralls
branches:
except:
- /^[0-9]/