def testSerialServerConnect(self): with patch.object(serial, 'Serial') as mock_serial: mock_serial.return_value = "socket" identity = ModbusDeviceIdentification(info={0x00: 'VendorName'}) server = ModbusSerialServer(context=None, identity=identity) self.assertEqual(server.socket, "socket") self.assertEqual(server.control.Identity.VendorName, 'VendorName') server._connect() self.assertEqual(server.socket, "socket") with patch.object(serial, 'Serial') as mock_serial: mock_serial.side_effect = serial.SerialException() server = ModbusSerialServer(None) self.assertEqual(server.socket, None)
def testSerialServerClose(self): ''' test that the synchronous serial server closes correctly ''' with patch.object(serial, 'Serial') as mock_serial: instance = mock_serial.return_value server = ModbusSerialServer(None) server.server_close() instance.close.assert_any_call()
def run_rtu(args, server_context): server = ModbusSerialServer( context=server_context, framer=ModbusRtuFramer, port=args.path, baudrate=args.baud, timeout=0.005) server.serve_forever()
def testSerialServerServeForever(self): ''' test that the synchronous serial server closes correctly ''' with patch.object(serial, 'Serial') as mock_serial: with patch('pymodbus.server.sync.ModbusSingleRequestHandler') as mock_handler: server = ModbusSerialServer(None) instance = mock_handler.return_value instance.handle.side_effect = server.server_close server.serve_forever() instance.handle.assert_any_call()
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 main(): """ The main body of the emulator. This listens for incoming requests and processes them. It starts by initializing the context from config, then listening on the given serial device. """ slaves = dict() for device in emulator_config['devices']: # for each device (unit), create an EmulatorDataBlock that has the register # map defined in config def _convert_register(v): # pylint: disable=missing-docstring if isinstance(v, list): # return a list of converted values return [int(x, 16) for x in v] # convert single value to int return int(v, 16) block = EmulatorDataBlock({ int(k, 16): _convert_register(v) for k, v in device['holding_registers'].items() }) logger.error('Device: {} Block: {}'.format(device['device_address'], block.values)) store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block) slaves[device['device_address']] = store context = ModbusServerContext(slaves=slaves, single=False) for slave in context: logger.error('Slaves: {}'.format(slave[0])) identity = ModbusDeviceIdentification() identity.VendorName = 'Vapor IO' identity.ProductName = 'Synse Modbus Emulator' identity.MajorMinorRevision = '1.4' # this is done to allow us to actually use RTU framing which the Start shortcut prevents server = ModbusSerialServer(context, framer=ModbusRtuFramer, identity=identity, port=emulator_config['serial_device'], timeout=0.01) server.serve_forever()
def __init__(self, port, unit, data, baud, par, sec, parent): super(MBSerialServer, self).__init__(parent) self.slave = MBSlave(ModbusSequentialDataBlock(1, data[0]), ModbusSequentialDataBlock(1, data[1]), ModbusSequentialDataBlock(1, data[2]), ModbusSequentialDataBlock(1, data[3])) self.ctx = ModbusServerContext(slaves={unit: self.slave}, single=False) sb = par == 'N' and 2 or 1 self.server = ModbusSerialServer(self.ctx, framer=MRF, port=port, stopbits=sb, bytesize=8, parity=par, baudrate=baud, timeout=sec) print(self.server)
def __configureServer(self): if self.cfg["method"] == "tcp": self.servTCP = ModbusTcpServer(self.context, identity=self.identity, address=(self.__getIPAddress(), self.cfg["tcpPort"])) elif self.cfg["method"] == "rtu": self.servRTU = ModbusSerialServer(self.context, framer=ModbusRtuFramer, identity=self.identity, port=self.cfg["rtuPort"], stopbits=self.cfg["stopbits"], bytesize=self.cfg["bytesize"], parity=self.cfg["parity"], baudrate=self.cfg["baudrate"], timeout=self.cfg["timeout"]) else: raise ReferenceError("Invalid server type")
def __init__(self, serial_port='/dev/pts/4', json_device_desc_path=DEVICE_JSON_DESC_PATH): threading.Thread.__init__(self, name='MockTracerBN2') self._serial_port = serial_port # Build data backing store from json file. mappings = json_mapping_parser(json_device_desc_path) store = ModbusSlaveContext(di=ModbusSparseDataBlock(mappings['di']), co=ModbusSparseDataBlock(mappings['co']), ir=ModbusSparseDataBlock(mappings['ir']), hr=ModbusSparseDataBlock(mappings['hr'])) identity = initialise_device_identity(mappings) context = ModbusServerContext(slaves=store, single=True) # RTU: self.server = ModbusSerialServer(context, framer=ModbusRtuFramer, identity=identity, port=self._serial_port, timeout=0.001, baudrate=115200)