def testUdpServerSendData(self):
''' Test that the modbus udp asyncio server correctly sends data outbound '''
identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
data = b'x\01\x00\x00\x00\x00\x06\x01\x03\x00\x00\x00\x19'
server = yield from StartUdpServer(context=self.context,
address=("127.0.0.1", 0))
if PYTHON_VERSION >= (3, 7):
server_task = asyncio.create_task(server.serve_forever())
else:
server_task = asyncio.ensure_future(server.serve_forever())
yield from server.serving
random_port = server.protocol._sock.getsockname()[1]
received = server.endpoint.datagram_received = Mock(
wraps=server.endpoint.datagram_received)
done = self.loop.create_future()
received_value = None
class BasicClient(asyncio.DatagramProtocol):
def connection_made(self, transport):
self.transport = transport
self.transport.sendto(data)
def datagram_received(self, data, addr):
nonlocal received_value, done
print("received")
received_value = data
done.set_result(True)
self.transport.close()
transport, protocol = yield from self.loop.create_datagram_endpoint(
BasicClient, remote_addr=('127.0.0.1', random_port))
yield from asyncio.sleep(0.1)
if PYTHON_VERSION >= (3, 6):
received.assert_called_once()
self.assertEqual(received.call_args[0][0], data)
server.server_close()
self.assertTrue(server.protocol.is_closing())
yield from asyncio.sleep(0.1)
def __init__(self,
port=1234,
sub_topic="modbus_server/write_to_registers",
pub_topic="modbus_server/read_from_registers"):
"""
Creates a Modbus TCP Server object
.. note:: The default port for modbus is 502. This modbus server uses port 1234 by default, otherwise superuser rights are required.
.. note:: Use "startServer" to start the listener.
:param port: Port for the modbus TCP server
:type port: int
:param sub_topic: ROS topic name for the subscriber that updates the modbus registers
:type sub_topic: string
:param pub_topic: ROS topic name for the publisher that publishes a message, once there is something written to the writeable modbus registers
:type pub_topic: string
"""
chr = CustomHoldingRegister(ADDRESS_WRITE_START, [17] * 100, sub_topic,
pub_topic)
self.store = ModbusSlaveContext(
di=ModbusSequentialDataBlock(ADDRESS_WRITE_START, [17] * 100),
co=ModbusSequentialDataBlock(ADDRESS_WRITE_START, [17] * 100),
hr=chr,
ir=ModbusSequentialDataBlock(ADDRESS_WRITE_START, [17] * 100))
self.context = ModbusServerContext(slaves=self.store, single=True)
self.identity = ModbusDeviceIdentification()
self.identity.VendorName = 'Pymodbus'
self.identity.ProductCode = 'PM'
self.identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
self.identity.ProductName = 'Pymodbus Server'
self.identity.ModelName = 'Pymodbus Server'
self.identity.MajorMinorRevision = '1.0'
self.store.setValues(2, 0, [0] * 1)
self.post = Post(self)
framer = ModbusSocketFramer
self.server = ModbusTcpServer(self.context,
framer,
self.identity,
address=("0.0.0.0", port))
def run_updating_server():
# initialize data store
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [17] * 100),
ir=ModbusSequentialDataBlock(0, [17] * 100))
context = ModbusServerContext(slaves=store, single=True)
# initialize the server information
identity = ModbusDeviceIdentification()
identity.VendorName = 'pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'pymodbus Server'
identity.ModelName = 'pymodbus Server'
identity.MajorMinorRevision = '2.2.0'
loop = LoopingCall(f=update_context, a=(context, ))
loop.start(0.5, now=False)
StartTcpServer(context, identity=identity, address=("0.0.0.0", 502))
def run_payload_server():
"""
Creates the Modbus server and starts it.
"""
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [17] * 100),
ir=ModbusSequentialDataBlock(0, [17] * 100))
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = 'AWS Greengrass Samples'
identity.ProductCode = 'AWS'
identity.VendorUrl = 'https//github.com/aws-samples/aws-greengrass-samples'
identity.ProductName = 'Sample Local Server'
identity.ModelName = 'LocalServer'
identity.MajorMinorRevision = '1.0'
StartTcpServer(context, identity=identity, address=("127.0.0.1", 5020))
def __init__(self, host, port):
super(Modbus_server, self).__init__()
self.host = host
self.port = port
log.info("starting Modbus server on {}:{}".format(
self.host, self.port))
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [0] * 1),
co=ModbusSequentialDataBlock(0, [0] * 1),
hr=ModbusSequentialDataBlock(0, [0] * 5000),
ir=ModbusSequentialDataBlock(0, [0] * 1))
self.context = ModbusServerContext(slaves=store, single=True)
self.identity = ModbusDeviceIdentification()
self.identity.VendorName = 'Pymodbus'
self.identity.ProductCode = 'PM'
self.identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
self.identity.ProductName = 'Pymodbus Server'
self.identity.ModelName = 'Pymodbus Server'
self.identity.MajorMinorRevision = '1.0'
def __init__(self, config, params):
'''
'''
print("ModBus init")
self.update_interval = config.update_interval
self.params = params
block = CallbackDataBlock(params)
store = ModbusSlaveContext(di=block,
co=block,
hr=block,
ir=block,
zero_mode=True)
slave = {
0x02: store,
}
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = 'WK'
identity.ProductCode = 'XX'
identity.VendorUrl = 'http://xxx.xxx'
identity.ProductName = 'ModBus Server'
identity.ModelName = 'ModBus Server'
identity.MajorMinorRevision = '1.0'
# prepare and start ModBus process
# self.test_thread = threading.Thread(target=self.setter_function, args=(queue, ))
# self.test_thread.start()
time = 2 # 5 seconds delay
StartSerialServer(context,
identity=identity,
port='/dev/ttyUSB0',
stopbits=1,
bytesize=8,
parity='N',
baudrate=9600,
framer=ModbusRtuFramer)
def __init__(self, config, _id, queue):
handle = config
# print(handle)
self._id = _id
self.port = int(handle['port'])
self.di = handle['di']
self.co = handle['co']
self.hr = handle['hr']
self.ir = handle['ir']
self.t = None
logger.info(handle)
self.data_queue: Queue = queue
self.store = ModbusSlaveContext(
di=CallbackDataBlock(self.data_queue, 0, self._id),
co=CallbackDataBlock(self.data_queue, 1, self._id),
hr=CallbackDataBlock(self.data_queue, 2, self._id),
ir=CallbackDataBlock(self.data_queue, 3, self._id))
self.handle = handle
self.identity = ModbusDeviceIdentification()
self.context = ModbusServerContext(slaves={0: self.store},
single=False)
def run_server():
store = ModbusSlaveContext(
di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [17] * 100),
ir=ModbusSequentialDataBlock(0, [17] * 100),
)
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = "Pymodbus"
identity.ProductCode = "PM"
identity.VendorUrl = "http://github.com/riptideio/pymodbus/"
identity.ProductName = "Pymodbus Server"
identity.ModelName = "Pymodbus Server"
identity.MajorMinorRevision = version.short()
# socat -d -d PTY,link=/tmp/ptyp0,raw,echo=0,ispeed=9600 PTY,link=/tmp/ttyp0,raw,echo=0,ospeed=9600
StartSerialServer(context, identity=identity, port="/dev/ttyp0", timeout=1)
def __init__(self, config, modbus_callback):
self._log = logging.getLogger(logger_name)
self._config = config
self._log.info("Initializing Modbus slave")
self._modbus_callback = modbus_callback
self.store = ModbusSlaveContext(
di=ModbusSequentialDataBlock(1, [0] * 384)
# di = ModbusSequentialDataBlock(1, [0]*192)
)
self.context = ModbusServerContext(slaves=self.store, single=True)
self.identity = ModbusDeviceIdentification()
self.identity.VendorName = 'blbecek.net'
self.identity.ProductCode = 'PARADOX'
self.identity.VendorUrl = 'https://github.com/czertique/paradox-modbus/'
self.identity.ProductName = 'paradox-modbus interface'
self.identity.ModelName = 'paradox-modbus interface'
self.identity.MajorMinorRevision = '1.0'
def init():
slaves = {
UNIT: ModbusSlaveContext(
di=ModbusSequentialDataBlock(0, [0]*50),
co=ModbusSequentialDataBlock(0, [0]*50),
hr=ModbusSequentialDataBlock(0, [0]*50),
ir=ModbusSequentialDataBlock(0, [0]*50)
)
}
context = ModbusServerContext(slaves=slaves, single=False)
identity = ModbusDeviceIdentification()
identity.VendorName = 'HAXOM'
identity.ProductCode = 'SIMU-ICS-EOLIENNE'
identity.VendorUrl = 'https://github.com/haxom/'
identity.ProductName = 'SIMU-ICS'
identity.ModelName = 'EOLIENNE'
identity.MajorMinorRevision = '1.0.0'
print 'Launching Modbus server, listening on %s:%d' % (listen_int, listen_port)
StartTcpServer(context, identity=identity, address=(listen_int, listen_port))
def __init__(self, server="tcp", *args, **kwargs):
# initialize server information
self.identity = ModbusDeviceIdentification()
self._add_device_info()
self._server_type = server
self._port = kwargs.get('port', None)
self.context = ModbusServerContext(single=False)
self.simulate = kwargs.get('simulate', False)
self.dirty = False
if server == "tcp":
self._port = int(self._port)
self._address = kwargs.get("address", "localhost")
self.server = ModbusTcpServer(self.context,
identity=self.identity,
address=(self._address, self._port))
else:
self.server = MbusSerialServer(self.context,
framer=ModbusRtuFramer,
identity=self.identity, **kwargs)
self.server_thread = ThreadedModbusServer(self.server)
def run_updating_server():
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [0] * 0xff),
co=ModbusSequentialDataBlock(0, [0] * 0xff),
hr=ModbusSequentialDataBlock(0, [0] * 0xff),
ir=ModbusSequentialDataBlock(0, [0] * 0xff))
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = 'pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'pymodbus Server'
identity.ModelName = 'pymodbus Server'
identity.MajorMinorRevision = '1.0'
start_new_thread(updating_writer, (context, ))
StartSerialServer(context,
framer=ModbusRtuFramer,
identity=identity,
port='/dev/ttyUSB0',
timeout=.005,
baudrate=9600)
def run_updating_server():
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #
store1 = ModbusSlaveContext(di=ModbusSparseDataBlock({0x10: 12}),
cp=ModbusSparseDataBlock({0x10: 13}),
hr=ModbusSparseDataBlock({0x10: 14}),
ir=ModbusSparseDataBlock({0x100: 7000}))
store2 = ModbusSlaveContext(di=ModbusSparseDataBlock({0x10: 12}),
cp=ModbusSparseDataBlock({0x10: 13}),
hr=ModbusSparseDataBlock({0x10: 14}),
ir=ModbusSparseDataBlock({0x100: 7000}))
slaves = {
28: ModbusSlaveContext(slaves=store1),
48: ModbusSlaveContext(slaves=store2)
}
context = ModbusServerContext(slaves=slaves, single=False)
# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
identity.VendorName = 'pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'pymodbus Server'
identity.ModelName = 'pymodbus Server'
identity.MajorMinorRevision = '2.2.0'
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
time = 0.1
loop = LoopingCall(f=updating_writer, a=(context, ))
loop.start(time, now=False) # initially delay by time
StartTcpServer(context, identity=identity, address=("0.0.0.0", 5020))
def run(self) -> None:
builder = BinaryPayloadBuilder(byteorder=self.endian,
wordorder=self.endian)
builder.add_32bit_uint(42)
builder.add_16bit_uint(12)
builder.add_32bit_int(64)
builder.add_16bit_int(128)
builder.add_32bit_float(256)
store = ModbusSlaveContext(
di=ModbusSequentialDataBlock(18476, builder.to_registers()),
co=ModbusSequentialDataBlock(18476, builder.to_registers()),
hr=ModbusSequentialDataBlock(18476, builder.to_registers()),
ir=ModbusSequentialDataBlock(18476, builder.to_registers()),
zero_mode=True
)
slaves = {
0x01: store,
0x02: store,
0x03: store,
0x04: store,
}
# context = ModbusServerContext(slaves=store, single=True)
context = ModbusServerContext(slaves=slaves, single=False)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
identity.ProductName = 'Pymodbus Server'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '2.3.0'
framer = ModbusSocketFramer
self.server = ModbusTcpServer(context, framer, identity, address=("127.0.0.1", self.port))
self.server.serve_forever()
def run_server():
data_list = turn_float_int(simulate_env())
log.debug("register data is {}".format(data_list))
store = ModbusSlaveContext(
di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [17] +
data_list), ## start at index 1 not 0
# hr=ModbusSequentialDataBlock(0, [20.1,20.1,20.1,20.1,20.1]),
ir=ModbusSequentialDataBlock(0, [17] * 100))
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
identity.ProductName = 'Pymodbus Server'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '1.5'
StartTcpServer(context, identity=identity, address=("192.168.0.110", 5020))
def __init__(self, address, port):
self.coil = CoilDataBlock()
self.discrete_input = DiscreteInputDataBlock()
self.input_register = InputRegisterDataBlock()
self.holding_register = HoldingRegisterDataBlock()
self.store = ModbusSlaveContext(di=self.discrete_input,
co=self.coil,
hr=self.holding_register,
ir=self.input_register)
self.context = ModbusServerContext(slaves=self.store, single=True)
self.identity = ModbusDeviceIdentification()
self.identity.VendorName = 'pymodbus'
self.identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
self.identity.ProductName = 'pymodbus Server'
self.identity.ModelName = 'pymodbus Server'
self.identity.MajorMinorRevision = '1.0'
self.server = ModbusTcpServer(context=self.context,
framer=None,
identity=self.identity,
address=(address, port))
def run_updating_server():
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [17] * 100),
ir=ModbusSequentialDataBlock(0, [17] * 100))
#context = ModbusServerContext(slaves=store, single=True)
slaves = {0x10: store}
context = ModbusServerContext(slaves=slaves, single=False)
# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
identity.VendorName = 'pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'pymodbus Server'
identity.ModelName = 'pymodbus Server'
identity.MajorMinorRevision = '2.2.0'
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
time = 5 # 5 seconds delay
# loop = LoopingCall(f=updating_writer, a=(context,))
# loop.start(time, now=False) # initially delay by time
StartSerialServer(
context,
identity=identity,
port="/dev/ttyUSB0",
framer=ModbusRtuFramer,
# stopbits=1,
# bytesize=8,
# parity='E',
baudrate=115200)
def init():
slaves = {
UNIT:
ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [17] * 100),
ir=ModbusSequentialDataBlock(0, [17] * 100))
}
context = ModbusServerContext(slaves=slaves, single=False)
identity = ModbusDeviceIdentification()
identity.VendorName = 'HAXOM'
identity.ProductCode = 'SIMU-ICS-TEMPLATE'
identity.VendorUrl = 'https://github.com/haxom/'
identity.ProductName = 'SIMU-ICS'
identity.ModelName = 'TEMPLATE'
identity.MajorMinorRevision = '1.0.0'
print(f'Modbus slave launched on {listen_int}:{listen_port}')
StartTcpServer(context,
identity=identity,
address=(listen_int, listen_port))
def main():
logging.basicConfig()
#server_log = logging.getLogger("pymodbus.server")
#protocol_log = logging.getLogger("pymodbus.protocol")
""" Server launcher """
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-D",
"--debug",
help="Turn on to enable tracing",
action="store_true",
dest="debug",
default=False)
(opt, arg) = parser.parse_args()
# enable debugging information
if opt.debug:
try:
_logger.setLevel(logging.DEBUG)
except Exception:
print "Logging is not supported on this system"
# Create store context
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [17] * 100),
ir=ModbusSequentialDataBlock(0, [17] * 100))
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://unipi.technology'
identity.ProductName = 'Pymodbus Server on IOLoop'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '1.0'
StartTcpServer(context, identity=identity, address=("localhost", 5020))
def run_server():
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [17] * 100),
co=ModbusSequentialDataBlock(0, [17] * 100),
hr=ModbusSequentialDataBlock(0, [5] * 100),
ir=ModbusSequentialDataBlock(0, [17] * 100))
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
identity.ProductName = 'Pymodbus Server'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '1.5'
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
# Tcp:
StartTcpServer(context, identity=identity, address=("localhost", 5020))
def __init__(self, name=None):
self.connected_sensors = {}
self.slaveid = 0x00
self.name = name
if not name:
self.name = socket.gethostname()
self.plcrpcclient = PLCRPCClient(rpc_server="0.0.0.0",
rpc_port=8000,
plc=self.name)
self.registered = False
identity = ModbusDeviceIdentification()
identity.VendorName = 'scadasim'
identity.ProductCode = 'PLC'
identity.VendorUrl = 'https://github.com/sintax1/scadasim-plc'
identity.ProductName = 'scadasim-PLC'
identity.ModelName = 'SimPLC'
identity.MajorMinorRevision = '1.0'
self.identity = identity
self.speed = 0.2
self.queue = Queue()
self.context = None
def run_update_server():
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #
store = ModbusSlaveContext(
di=ModbusSequentialDataBlock(0, range(1, 101)),
co=ModbusSequentialDataBlock(0, range(101, 201)),
hr=ModbusSequentialDataBlock(0, range(201, 301)),
ir=ModbusSequentialDataBlock(0, range(301, 401)))
context = ModbusServerContext(slaves=store, single=True)
# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
identity.VendorName = 'pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'pymodbus Server'
identity.ModelName = 'pymodbus Server'
identity.MajorMinorRevision = '1.0'
# connect to simulation
HOST = '127.0.0.1'
PORT = 55555
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
time = 1 # 5 seconds delay
loop = LoopingCall(f=updating_writer, a=(context, sock))
loop.start(time, now=False) # initially delay by time
StartTcpServer(context,
identity=identity,
address=(purge_ip_address, modbusTCP_port))
def run_modbus_server():
# initialize your data store
queue = Queue()
devices = read_device_map()
block = CallbackDataBlock(devices, queue)
store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
context = ModbusServerContext(slaves=store, single=True)
# initialize the server information
identity = ModbusDeviceIdentification()
identity.VendorName = 'BUCHI Labortechnik AG'
identity.ProductCode = 'R-300'
identity.VendorUrl = 'https://www.buchi.com/'
identity.ProductName = 'Rotavapor R-300'
identity.ModelName = 'Rotavapor Modbus Server'
identity.MajorMinorRevision = '1.0.0.0'
# run updating thread
t1 = Thread(target=updating_writer, args=(context, ))
t1.start()
# run writing thread
t2 = Thread(target=device_writer, args=(queue, ))
t2.start()
# run modbus server
if modbus_type == 'TCP':
StartTcpServer(context,
identity=identity,
address=(modbus_ip, modbus_tcpport))
elif modbus_type == 'RTU':
# this part doesn't work because bug in pymodbus, more info: https://github.com/riptideio/pymodbus/issues/514
StartSerialServer(context,
framer=ModbusRtuFramer,
identity=identity,
port=modbus_port,
baudrate=modbus_baudrate,
parity=modbus_parity)
def testTlsServerInit(self):
''' test that the synchronous TLS server initial correctly '''
with patch.object(socketserver.TCPServer, 'server_activate'):
with patch.object(ssl.SSLContext,
'load_cert_chain') as mock_method:
identity = ModbusDeviceIdentification(
info={0x00: 'VendorName'})
server = ModbusTlsServer(context=None,
identity=identity,
bind_and_activate=False)
server.server_activate()
self.assertIsNotNone(server.sslctx)
self.assertEqual(type(server.socket), ssl.SSLSocket)
server.server_close()
sslctx = ssl.create_default_context()
server = ModbusTlsServer(context=None,
identity=identity,
sslctx=sslctx,
bind_and_activate=False)
server.server_activate()
self.assertEqual(server.sslctx, sslctx)
self.assertEqual(type(server.socket), ssl.SSLSocket)
server.server_close()
def run_server():
cc_store = ModbusSlaveContext(
di = ModbusSequentialDataBlock(0, [30] * 100), # discrete input space
co = ModbusSequentialDataBlock(0, [40] * 100), # c o space
hr = ModbusSequentialDataBlock(0, [0] * 81) , #
ir = ModbusSequentialDataBlock(0, [50] * 100),
) # input registers space
rb_store = ModbusSlaveContext(
di = ModbusSequentialDataBlock(0, [30] * 100), # discrete input space
co = ModbusSequentialDataBlock(0, [40] * 100), # c o space
hr = ModbusSequentialDataBlock(0, [1] * 20) , #
ir = ModbusSequentialDataBlock(0, [50] * 100),
) # input registers space
store = {0x01 : cc_store , 0x09 : rb_store }
context = ModbusServerContext(slaves=store, single=False)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Gionji'
identity.ProductCode = 'AGB'
identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
identity.ProductName = 'Pymodbus Server Sim'
identity.ModelName = 'Pymodbus Sim '
identity.MajorMinorRevision = '0.1'
# UPDATER
time = 1
updater = updaterThread(context, updating_writer)
updater.start()
#updating_writer(context)
StartTcpServer(context, identity=identity, address=("", 5020))
def run_updating_server():
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #
store = ModbusSlaveContext(
di=ModbusSequentialDataBlock(0, [17] * 1),
co=ModbusSequentialDataBlock(0, [17] * 1),
hr=ModbusSequentialDataBlock(1, [17] * 20),
ir=ModbusSequentialDataBlock(0, [17] * 1))
context = ModbusServerContext(slaves=store, single=True)
# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
identity.VendorName = 'pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'pymodbus Server'
identity.ModelName = 'pymodbus Server'
identity.MajorMinorRevision = '1.0'
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
time = 5 # 5 seconds delay
loop = LoopingCall(f=updating_writer, a=(context,))
loop.start(time, now=False) # initially delay by time
StartSerialServer(context, identity=identity, port='/dev/ttyUSB0', framer=ModbusRtuFramer, stopbits=2, parity='none', baudrate=9600, UnitId=0x01, ignore_missing_slaves=True)
def run_payload_server():
# ----------------------------------------------------------------------- #
# build your payload
# ----------------------------------------------------------------------- #
builder = BinaryPayloadBuilder(byteorder=Endian.Little)
# builder.add_string('abcdefgh')
# builder.add_32bit_float(22.34)
# builder.add_16bit_uint(4660)
# builder.add_8bit_int(18)
builder.add_bits([0, 1, 0, 1, 1, 0, 1, 0])
# ----------------------------------------------------------------------- #
# use that payload in the data store
# ----------------------------------------------------------------------- #
# Here we use the same reference block for each underlying store.
# ----------------------------------------------------------------------- #
block = ModbusSequentialDataBlock(1, builder.to_registers())
store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
context = ModbusServerContext(slaves=store, single=True)
# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
# If you don't set this or any fields, they are defaulted to empty strings.
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'Pymodbus Server'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '1.0'
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
StartTcpServer(context, identity=identity, address=("localhost", 5020))
def run_custom_db_server(address, port):
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #
coil_block = ModbusSequentialDataBlock(1, [0] * 256)
discrete_input_block = ModbusSequentialDataBlock(10001, [0] * 256)
input_register_block = ModbusSequentialDataBlock(30001, register_data)
holding_register_block = ModbusSequentialDataBlock(40001, register_data)
store = ModbusSlaveContext(di=discrete_input_block,
co=coil_block,
hr=holding_register_block,
ir=input_register_block,
zero_mode=True)
context = ModbusServerContext(slaves=store, single=True)
# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
identity.VendorName = 'pymodbus'
identity.ProductCode = 'PM'
identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
identity.ProductName = 'pymodbus Server'
identity.ModelName = 'pymodbus Server'
identity.MajorMinorRevision = '2.3.0'
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
# p = Process(target=device_writer, args=(queue,))
# p.start()
StartTcpServer(context,
identity=identity,
address=(address, port),
framer=ModbusRtuFramer)
def testSerialServerConnect(self):
with patch.object(serial, 'Serial') as mock_serial:
# mock_serial.return_value = "socket"
mock_serial.write = lambda x: len(x)
mock_serial.read = lambda size: '\x00' * size
identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
server = ModbusSerialServer(context=None,
identity=identity,
port="dummy")
# # mock_serial.return_value = "socket"
# self.assertEqual(server.socket.port, "dummy")
self.assertEquals(server.handler.__class__.__name__,
"CustomSingleRequestHandler")
self.assertEqual(server.control.Identity.VendorName, 'VendorName')
server._connect()
# self.assertEqual(server.socket, "socket")
with patch.object(serial, 'Serial') as mock_serial:
mock_serial.write = lambda x: len(x)
mock_serial.read = lambda size: '\x00' * size
mock_serial.side_effect = serial.SerialException()
server = ModbusSerialServer(None, port="dummy")
self.assertEqual(server.socket, None)
def run_server():
store = ModbusSlaveContext(di=ModbusSequentialDataBlock(0, [0] * 10000),
co=ModbusSequentialDataBlock(0, [0] * 10000),
hr=ModbusSequentialDataBlock(0, [0] * 10000),
ir=ModbusSequentialDataBlock(0, [0] * 10000))
context = ModbusServerContext(slaves=store, single=True)
identity = ModbusDeviceIdentification()
identity.VendorName = 'Pymodbus'
identity.ProductCode = 'PM'
# identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
identity.ProductName = 'Pymodbus Server'
identity.ModelName = 'Pymodbus Server'
identity.MajorMinorRevision = '1.5'
#-----------------------------------------------------
print("debug started\n\n")
print(dir(store))
store.setValues(3, 53, [30000])
print("\n\ndebug finished")
#-----------------------------------------------------
print("Listening on {}:{}".format(HOST, PORT))
StartTcpServer(context, identity=identity, address=(HOST, PORT))
