def __init__(self, port, baud=9600):
self.port = port
self.baud = baud
self.connection = serial.Serial(
port,
baud,
timeout=float(self.kByteLength * self.kMaxReadSize) / baud)
self.client_framer = ModbusRtuFramer(decoder=ClientDecoder())
self.server_framer = ModbusRtuFramer(decoder=ServerDecoder())
def __implementation(method):
''' Returns the requested framer
:method: The serial framer to instantiate
:returns: The requested serial framer
'''
method = method.lower()
if method == 'rtu': return ModbusRtuFramer(ClientDecoder())
raise ParameterException("Invalid framer method requested")
def testSerialClientInit(self):
""" Test the tornado serial client client initialize """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP, framer=ModbusRtuFramer(ClientDecoder()), port=SERIAL_PORT)
self.assertEqual(0, len(list(client.transaction)))
self.assertTrue(isinstance(client.framer, ModbusRtuFramer))
framer = object()
client = AsyncModbusSerialClient(framer=framer)
self.assertTrue(framer is client.framer)
def testSerialClientConnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client connect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertTrue(client.port, SERIAL_PORT)
self.assertFalse(client._connected)
client.connect()
self.assertTrue(client._connected)
client.close()
def setUp(self):
''' Sets up the test environment '''
self.client = None
self.decoder = ServerDecoder()
self._tcp = ModbusSocketFramer(decoder=self.decoder)
self._rtu = ModbusRtuFramer(decoder=self.decoder)
self._ascii = ModbusAsciiFramer(decoder=self.decoder)
self._binary = ModbusBinaryFramer(decoder=self.decoder)
self._manager = DictTransactionManager(self.client)
self._queue_manager = FifoTransactionManager(self.client)
self._tm = ModbusTransactionManager(self.client)
def _framer(method):
if method == "ascii":
framer = ModbusAsciiFramer(ClientDecoder())
elif method == "rtu":
framer = ModbusRtuFramer(ClientDecoder())
elif method == "binary":
framer = ModbusBinaryFramer(ClientDecoder())
elif method == "socket":
framer = ModbusSocketFramer(ClientDecoder())
else:
framer = None
return framer
def testSerialClientExecute(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client execute method """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
client.stream = Mock()
client.stream.write = Mock()
request = ReadCoilsRequest(1, 1)
d = client.execute(request)
tid = request.transaction_id
self.assertEqual(d, client.transaction.getTransaction(tid))
def __implementation(method, client):
""" Returns the requested framer
:method: The serial framer to instantiate
:returns: The requested serial framer
"""
method = method.lower()
if method == 'ascii':
return ModbusAsciiFramer(ClientDecoder(), client)
elif method == 'rtu':
return ModbusRtuFramer(ClientDecoder(), client)
elif method == 'binary':
return ModbusBinaryFramer(ClientDecoder(), client)
elif method == 'socket':
return ModbusSocketFramer(ClientDecoder(), client)
raise ParameterException("Invalid framer method requested")
def testSerialClientDisconnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client disconnect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
self.assertTrue(client._connected)
def handle_failure(failure):
self.assertTrue(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
client.close()
self.assertFalse(client._connected)
def testSerialClientBuildResponse(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client builds responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertEqual(0, len(list(client.transaction)))
def handle_failure(failure):
exc = failure.exception()
self.assertTrue(isinstance(exc, ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertEqual(0, len(list(client.transaction)))
client._connected = True
d = client._build_response(0x00)
self.assertEqual(1, len(list(client.transaction)))
def testSerialClientHandleResponse(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client handles responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
out = []
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
client._handle_response(None)
client._handle_response(reply)
# handle existing cases
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client._handle_response(reply)
self.assertEqual(d.result(), reply)
def __init__(self, framer=None, **kwargs):
framer = framer or ModbusRtuFramer(ClientDecoder())
super(ModbusSerClientProtocol, self).__init__(framer, **kwargs)
def make_protocol():
return ModbusClientProtocol(framer=ModbusRtuFramer(ClientDecoder()))
