class ControlLink(object):
def __init__(self, host, port=Defaults.Port):
self.conn = ModbusTcpClient(host, port)
if not self.conn.connect():
raise RuntimeError('Could not connect to host %s port %d' % (host, port))
def read(self, offset):
# Adjust offset due to weirdness.
offset -= 40000
# Create request.
assert offset is not None
assert offset >= 0
req = ReadInputRegistersRequest(offset, 1)
assert req is not None
# Execute and return response.
res = self.conn.execute(req)
assert res is not None
# Extract single value from response.
values = res.registers
assert values is not None
assert len(values) == 1
return long(values[0])
def write(self, offset, value):
# Adjust offset due to weirdness.
offset -= 40000
# Create request.
assert offset is not None
assert offset >= 0
assert value is not None
req = WriteSingleRegisterRequest(offset, value)
# Execute and return response.
res = self.conn.execute(req)
assert res is not None
assert res.value is not None
nvalue = res.value
if nvalue != value:
report('address %d, wrote %d, returned %d'
% (offset, value, nvalue))
return nvalue
def access_plc(ip, port):
global total_found
try:
client = ModbusTcpClient(ip, port=port)
req = ReadDeviceInformationRequest()
resp = client.execute(req)
print_info(resp.information, ip + ":" + str(port))
total_found += 1
except Exception as ex:
return
class MB():
def __init__(self, ip, port=502):
self.ip = ip
self.port = port
self.connect()
def connect(self):
self.client = ModbusTcpClient(self.ip, port=self.port, timeout=10)
def read_reg(self):
val = self.client.read_holding_registers(6, 2)
return val.registers
def write_reg(self, value):
self.client.write_register(6, scada_value)
return 0
def deviceinfo(self):
rq = mei_message.ReadDeviceInformationRequest()
val = self.client.execute(rq)
return (val.information)
def close(self):
self.client.close()
# # request = ClearCountersRequest() # response = client.execute(request) # if isinstance(response, ClearCountersResponse): # ... do something with the response # # # What follows is a listing of all the supported methods. Feel free to # comment, uncomment, or modify each result set to match with your reference. #---------------------------------------------------------------------------# #---------------------------------------------------------------------------# # information requests #---------------------------------------------------------------------------# rq = ReadDeviceInformationRequest() rr = client.execute(rq) #assert(rr == None) # not supported by reference assert (rr.function_code < 0x80) # test that we are not an error assert (rr.information[0] == 'proconX Pty Ltd') # test the vendor name assert (rr.information[1] == 'FT-MBSV') # test the product code assert (rr.information[2] == 'EXPERIMENTAL') # test the code revision rq = ReportSlaveIdRequest() rr = client.execute(rq) assert (rr == None) # not supported by reference #assert(rr.function_code < 0x80) # test that we are not an error #assert(rr.identifier == 0x00) # test the slave identifier #assert(rr.status == 0x00) # test that the status is ok rq = ReadExceptionStatusRequest() rr = client.execute(rq)
def run_sync_client():
# ------------------------------------------------------------------------#
# choose the client you want
# ------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#
# If you use the UDP or TCP clients, you can override the framer being used
# to use a custom implementation (say RTU over TCP). By default they use
# the socket framer::
#
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
#
# It should be noted that you can supply an ipv4 or an ipv6 host address
# for both the UDP and TCP clients.
#
# There are also other options that can be set on the client that controls
# how transactions are performed. The current ones are:
#
# * retries - Specify how many retries to allow per transaction (default=3)
# * retry_on_empty - Is an empty response a retry (default = False)
# * source_address - Specifies the TCP source address to bind to
#
# Here is an example of using these options::
#
# client = ModbusClient('localhost', retries=3, retry_on_empty=True)
# ------------------------------------------------------------------------#
client = ModbusClient('localhost', port=5020)
# from pymodbus.transaction import ModbusRtuFramer
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
# client = ModbusClient(method='binary', port='/dev/ptyp0', timeout=1)
# client = ModbusClient(method='ascii', port='/dev/ptyp0', timeout=1)
# client = ModbusClient(method='rtu', port='/dev/ptyp0', timeout=1,
# baudrate=9600)
client.connect()
# ------------------------------------------------------------------------#
# specify slave to query
# ------------------------------------------------------------------------#
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
# ----------------------------------------------------------------------- #
log.debug("Reading Device Information")
information = {}
rr = None
while not rr or rr.more_follows:
next_object_id = rr.next_object_id if rr else 0
rq = ReadDeviceInformationRequest(read_code=0x03, unit=UNIT,
object_id=next_object_id)
rr = client.execute(rq)
information.update(rr.information)
log.debug(rr)
print("Device Information : ")
for key in information.keys():
print(key, information[key])
# ----------------------------------------------------------------------- #
# You can also have the information parsed through the
# ModbusDeviceIdentificiation class, which gets you a more usable way
# to access the Basic and Regular device information objects which are
# specifically listed in the Modbus specification
# ----------------------------------------------------------------------- #
di = ModbusDeviceIdentification(info=information)
print('Product Name : ', di.ProductName)
# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
client.close()
debug_level = logging.DEBUG
# Start logger
logging.basicConfig()
log = logging.getLogger(__name__)
log.setLevel(debug_level)
logging.disable(debug_level)
try:
# Create client connection
log.info("Connecting to Huawei Converter..")
client = ModbusTcpClient('192.169.11.30')
# Extract information from the device
log.info("Getting Huawei Converter registers..")
for reg in Converter.holding_registers:
result = client.read_holding_registers(address=reg["address"], count=reg["nRegs"], unit=CONVERTER)
print(reg["name"] + ": " + reg["function"](result.registers))
log.debug(result.registers)
log.info("Getting Huawei Converter blocks..")
ClientDecoder.register(client.framer.decoder, function=huawei_block_functions.ReadBlockRegistersResponse)
for bl in Converter.blocks:
request = huawei_block_functions.ReadBlockRegistersResponse(block=bl["block"], slice=0, unit=CONVERTER)
result = client.execute(request)
print(bl["name"] + ": " + result.data)
# Close client connection
log.info("Closing connection..")
client.close()
except:
# Close client connection
log.error("Huawei Converter not found")
# # request = ClearCountersRequest() # response = client.execute(request) # if isinstance(response, ClearCountersResponse): # ... do something with the response # # # What follows is a listing of all the supported methods. Feel free to # comment, uncomment, or modify each result set to match with your reference. #---------------------------------------------------------------------------# #---------------------------------------------------------------------------# # information requests #---------------------------------------------------------------------------# rq = ReadDeviceInformationRequest() rr = client.execute(rq) #assert(rr == None) # not supported by reference assert(rr.function_code < 0x80) # test that we are not an error assert(rr.information[0] == 'proconX Pty Ltd') # test the vendor name assert(rr.information[1] == 'FT-MBSV') # test the product code assert(rr.information[2] == 'EXPERIMENTAL') # test the code revision rq = ReportSlaveIdRequest() rr = client.execute(rq) assert(rr == None) # not supported by reference #assert(rr.function_code < 0x80) # test that we are not an error #assert(rr.identifier == 0x00) # test the slave identifier #assert(rr.status == 0x00) # test that the status is ok rq = ReadExceptionStatusRequest() rr = client.execute(rq)
def run_sync_client():
# ------------------------------------------------------------------------#
# choose the client you want
# ------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#
# If you use the UDP or TCP clients, you can override the framer being used
# to use a custom implementation (say RTU over TCP). By default they use
# the socket framer::
#
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
#
# It should be noted that you can supply an ipv4 or an ipv6 host address
# for both the UDP and TCP clients.
#
# There are also other options that can be set on the client that controls
# how transactions are performed. The current ones are:
#
# * retries - Specify how many retries to allow per transaction (default=3)
# * retry_on_empty - Is an empty response a retry (default = False)
# * source_address - Specifies the TCP source address to bind to
# * strict - Applicable only for Modbus RTU clients.
# Adheres to modbus protocol for timing restrictions
# (default = True).
# Setting this to False would disable the inter char timeout
# restriction (t1.5) for Modbus RTU
#
#
# Here is an example of using these options::
#
# client = ModbusClient('localhost', retries=3, retry_on_empty=True)
# ------------------------------------------------------------------------#
client = ModbusClient(os.getenv('IP_SERVER'), port=5020)
# from pymodbus.transaction import ModbusRtuFramer
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
# client = ModbusClient(method='binary', port='/dev/ptyp0', timeout=1)
# client = ModbusClient(method='ascii', port='/dev/ptyp0', timeout=1)
# client = ModbusClient(method='rtu', port='/dev/ptyp0', timeout=1,
# baudrate=9600)
client.connect()
print(client.socket)
print(client.socket.getsockname())
rq = ReadDeviceInformationRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
response = QueryClient()
message = os.getenv('IP_SERVER')
message = message.encode("utf-8")
message = base64.b64encode(hashlib.sha256(message).digest())
message = message.decode("utf-8")
if message != response['hash']:
print("Error en autenticacion")
print(response)
print(message)
return
# ------------------------------------------------------------------------#
# specify slave to query
# ------------------------------------------------------------------------#
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
# ----------------------------------------------------------------------- #
#while (not client.is_socket_open()):
#log.debug("Socket not open, trying again")
#rq = client.write_coil(0, True, unit=UNIT)
while True:
log.debug("Reading Coils")
rr = client.read_coils(0, 1, unit=UNIT)
log.debug(rr)
# ----------------------------------------------------------------------- #
# example requests
# ----------------------------------------------------------------------- #
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that some modbus
# implementations differentiate holding/input discrete/coils and as such
# you will not be able to write to these, therefore the starting values
# are not known to these tests. Furthermore, some use the same memory
# blocks for the two sets, so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied asynchronous modbus server (script supplied).
# ----------------------------------------------------------------------- #
log.debug("Write to a Coil and read back")
rq = client.write_coil(0, True, unit=UNIT)
rr = client.read_coils(0, 1, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
assert (rr.bits[0] == True) # test the expected value
log.debug("Write to multiple coils and read back- test 1")
rq = client.write_coils(1, [True] * 8, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
rr = client.read_coils(1, 21, unit=UNIT)
assert (not rr.isError()) # test that we are not an error
resp = [True] * 21
# 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).
resp.extend([False] * 3)
assert (rr.bits == resp) # test the expected value
log.debug("Write to multiple coils and read back - test 2")
rq = client.write_coils(1, [False] * 8, unit=UNIT)
rr = client.read_coils(1, 8, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
assert (rr.bits == [False] * 8) # test the expected value
log.debug("Read discrete inputs")
rr = client.read_discrete_inputs(0, 8, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
log.debug("Write to a holding register and read back")
rq = client.write_register(1, 10, unit=UNIT)
rr = client.read_holding_registers(1, 1, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
assert (rr.registers[0] == 10) # test the expected value
log.debug("Write to multiple holding registers and read back")
rq = client.write_registers(1, [10] * 8, unit=UNIT)
rr = client.read_holding_registers(1, 8, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
assert (rr.registers == [10] * 8) # test the expected value
log.debug("Read input registers")
rr = client.read_input_registers(1, 8, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20] * 8,
}
log.debug("Read write registeres simulataneously")
rq = client.readwrite_registers(unit=UNIT, **arguments)
rr = client.read_holding_registers(1, 8, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
assert (rq.registers == [20] * 8) # test the expected value
assert (rr.registers == [20] * 8) # test the expected value
break
# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
client.close()
protocol_log = logging.getLogger("pysnmp.protocol")
store_log = logging.getLogger("pysnmp.store")
# Enable logging levels
server_log.setLevel(logging.DEBUG)
protocol_log.setLevel(logging.DEBUG)
client_log.setLevel(logging.DEBUG)
store_log.setLevel(logging.DEBUG)
# Initialize the logging
try:
logging.basicConfig()
except Exception, e:
print "Logging is not supported on this system"
from pymodbus.client.sync import ModbusTcpClient
import sys
client = ModbusTcpClient("10.10.10.1")
result = client.read_holding_registers(6, 1)
print(result.registers)
result2 = client.read_holding_registers(7, 1)
print(result2.registers)
from pymodbus import mei_message
rq = mei_message.ReadDeviceInformationRequest()
result3 = client.execute(rq)
print(result3.information)
client.close()
