zavolo/python-owen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
zavolo
2026-01-14 21:33:17 +03:00
commit 40d80ef55e
17 changed files with 2573 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
test/test_client.py Normal file
View File

@@ -0,0 +1,153 @@
#! /usr/bin/env python3
import unittest
from unittest.mock import MagicMock, patch
from pymodbus.client.sync import ModbusSerialClient
from pymodbus.pdu import ModbusResponse
from pymodbus.register_write_message import WriteMultipleRegistersResponse
from serial import Serial
from owen.client import ClientMixin, OwenError, OwenModbusClient, OwenSerialClient
from owen.device import TRM201
class FakeOwenSerialClient(OwenSerialClient):
def bus_exchange(self, packet: bytes) -> bytes:
return {b"#GHHGTMOHHRTO\r": b"#GHGMTMOHJHJGJISSTGTIPLKK\r", # чтение параметра "DEV" тип "STR"
b"#GHHGHUTIKGJI\r": b"#GHGHHUTIGGJKGK\r", # чтение параметра "A.LEN" тип "U8" без индекса
b"#GHHIRJURGGGGHQIV\r": b"#GHGJRJURGHGGGGQROU\r", # чтение параметра "DP" тип "U8" с индексом
b"#GHHGPVMIJIMK\r": b"#GHGIPVMIGGGHNHIR\r", # чтение параметра "ADDR" тип "U16" без индекса
b"#GHHGROTVJNPQ\r": b"#GHGJROTVKIQJIOOJKN\r", # чтение параметра "PV" тип "F24" без индекса
b"#GHHIUSIGGGGGTJIT\r": b"#GHGLUSIGKKJROGGGGGPVUS\r", # чтение параметра "SL.H" тип "F24" с индексом
b"#GHHGGIJJRIQN\r": b"#GHGJGIJJKNRKMLLNJK\r", # чтение параметра "N.ERR" тип "U24"
b"#GHGHHUTIGGJKGK\r": b"#GHGHHUTIGGJKGK\r", # запись параметра "A.LEN" тип "U8" без индекса
b"#GHGJQLQRGHGGGGPNOJ\r": b"#GHGJQLQRGHGGGGPNOJ\r", # запись параметра "CMP" тип "U8" с индексом
b"#GHGIPVMIGGGHNHIR\r": b"#GHGIPVMIGGGHNHIR\r", # запись параметра "ADDR" тип "U16" без индекса
b"#GHGJPPKMGGGGGGQMGJ\r": b"#GHGJPPKMGGGGGGQMGJ\r", # запись параметра "R.OUT" тип "F24" без индекса
b"#GHGLUSIGKKJROGGGGGPVUS\r": b"#GHGLUSIGKKJROGGGGGPVUS\r", # запись параметра "SL.H" тип "F24" с индексом
b"#GHGGGGUPJSUL\r": b"", # запись параметра "INIT" тип "U8" без индекса
}[packet]
class TestClientMixin(unittest.TestCase):
"""The unittest for ClientMixin."""
def setUp(self) -> None:
self.client = ClientMixin()
def tearDown(self) -> None:
del self.client
def test_check_index(self) -> None:
name = "A.LEN"
dev = TRM201["Owen"][name]
# correct index
self.assertEqual(None, self.client.check_index(name=name, dev=dev, index=None))
# invalid index
self.assertRaises(OwenError, lambda: self.client.check_index(name=name, dev=dev, index=1))
def test_check_value(self) -> None:
name = "DEV"
dev = TRM201["Owen"][name]
# correct value
self.assertIsNone(self.client.check_value(name=name, dev=dev, value=None))
# invalid value
self.assertRaises(OwenError, lambda: self.client.check_value(name=name, dev=dev, value=1))
name = "SP"
dev = TRM201["Owen"][name]
# correct value
self.assertTrue(10.0, self.client.check_value(name=name, dev=dev, value=10.0))
# invalid value (> max)
self.assertRaises(OwenError, lambda: self.client.check_value(name=name, dev=dev, value=10000))
# invalid value (< min)
self.assertRaises(OwenError, lambda: self.client.check_value(name=name, dev=dev, value=-10000))
# invalid value
self.assertRaises(OwenError, lambda: self.client.check_value(name=name, dev=dev, value=None))
class TestOwenSerialClient(unittest.TestCase):
"""The unittest for OwenSerialClient."""
@patch("serial.Serial", autospec=True)
def setUp(self, mock_serial: Serial) -> None:
self.client = FakeOwenSerialClient(transport=mock_serial, device=TRM201,
unit=1, addr_len_8=True)
def tearDown(self) -> None:
del self.client
def test_get_param(self) -> None:
# correct index
self.assertEqual(0, self.client.get_param(name="A.LEN", index=None))
self.assertEqual("ТРМ201", self.client.get_param(name="DEV", index=None))
self.assertEqual(1, self.client.get_param(name="DP", index=0))
self.assertEqual(1, self.client.get_param(name="ADDR", index=None))
self.assertEqual(81.578125, self.client.get_param(name="PV", index=0))
self.assertEqual(750.0, self.client.get_param(name="SL.H", index=0))
self.assertEqual((71, 46181), self.client.get_param(name="N.ERR", index=None))
# invalid index
self.assertRaises(OwenError, lambda: self.client.get_param(name="A.LEN", index=2))
def test_set_param(self) -> None:
# correct index and value
self.assertTrue(self.client.set_param(name="A.LEN", index=None, value=0))
self.assertTrue(self.client.set_param(name="CMP", index=0, value=1))
self.assertTrue(self.client.set_param(name="ADDR", index=None, value=1))
self.assertTrue(self.client.set_param(name="R.OUT", index=None, value=0.0))
self.assertTrue(self.client.set_param(name="SL.H", index=0, value=750.0))
self.assertRaises(OwenError, lambda: self.client.set_param(name="INIT", index=None, value=None))
# invalid index
self.assertRaises(OwenError, lambda: self.client.set_param(name="A.LEN", index=2, value=0))
# invalid value
self.assertRaises(OwenError, lambda: self.client.set_param(name="A.LEN", index=None, value=2))
self.assertRaises(OwenError, lambda: self.client.set_param(name="INIT", index=None, value=1))
class TestOwenModbusClient(unittest.TestCase):
"""The unittest for OwenModbusClient."""
@patch("pymodbus.client.sync.ModbusSerialClient", autospec=True)
def setUp(self, mock_modbus: ModbusSerialClient) -> None:
self.client = OwenModbusClient(transport=mock_modbus, device=TRM201, unit=1)
def tearDown(self) -> None:
del self.client
def test_check_error(self) -> None:
err = MagicMock(ModbusResponse)
err.isError.return_value = False
self.assertTrue(self.client.check_error(retcode=err))
err.isError.return_value = True
self.assertRaises(OwenError, lambda: self.client.check_error(retcode=err))
def test_set_param(self) -> None:
# correct index and value
value = 20.0
self.client.modify_value = MagicMock(return_value=value)
self.client.socket.write_registers = MagicMock(return_value=WriteMultipleRegistersResponse(1, 2))
self.assertTrue(self.client.set_param(name="SP", index=0, value=value))
# invalid index
self.assertRaises(OwenError, lambda: self.client.set_param(name="SP", index=2, value=value))
# invalid value
self.assertRaises(OwenError, lambda: self.client.set_param(name="SP", index=0, value=None))
def test_get_param(self) -> None:
# correct index
self.client._read = MagicMock(return_value=bytearray([0x1, 0x3, 0x2, 0x0, 0x1, 0x79, 0x84]))
self.client.modify_value = MagicMock(return_value=20.0)
self.assertEqual(20.0, self.client.get_param(name="SP", index=0))
# invalid index
self.assertRaises(OwenError, lambda: self.client.get_param(name="SP", index=2))
if __name__ == "__main__":
unittest.main()

158
test/test_protocol.py Normal file
View File

@@ -0,0 +1,158 @@
#! /usr/bin/env python3
import unittest
from owen.protocol import Owen, OwenError
class TestOwenProtocol(unittest.TestCase):
"""The unittest for Owen protocol."""
def setUp(self) -> None:
self.trm = Owen(unit=1, addr_len_8=True)
self.trm11 = Owen(unit=400, addr_len_8=False)
def tearDown(self) -> None:
del self.trm
del self.trm11
def test_fast_calc(self) -> None:
self.assertEqual(20158, self.trm.fast_calc(84, 159, 7))
self.assertEqual(5565, self.trm.fast_calc(18, 36695, 8))
self.assertEqual(53661, self.trm.fast_calc(71, 34988, 8))
self.assertEqual(60031, self.trm.fast_calc(72, 0, 7))
self.assertEqual(64238, self.trm.fast_calc(156, 23651, 7))
self.assertIsInstance(self.trm.fast_calc(156, 23651, 7), int)
def test_owen_crc16(self) -> None:
self.assertEqual(16434, self.trm.owen_crc16((1, 16, 30, 210)))
self.assertEqual(44267, self.trm.owen_crc16((1, 18, 200, 128, 0, 0)))
self.assertEqual(23007, self.trm.owen_crc16((1, 5, 225, 125, 195, 71, 230, 0, 0)))
self.assertEqual(40940, self.trm.owen_crc16((1, 5, 236, 32, 68, 59, 128, 0, 0)))
self.assertEqual(59803, self.trm.owen_crc16((1, 8, 45, 91, 52, 48, 48, 48, 46, 51, 48, 86)))
self.assertEqual(15584, self.trm.owen_crc16((1, 16, 232, 196)))
self.assertEqual(38212, self.trm.owen_crc16((1, 6, 214, 129, 49, 48, 50, 204, 208, 210)))
self.assertIsInstance(self.trm.owen_crc16((1, 6, 214, 129, 49, 48, 50, 204, 208, 210)), int)
def test_owen_hash(self) -> None:
self.assertEqual(7890, self.trm.owen_hash((21, 42, 28, 46)))
self.assertEqual(60448, self.trm.owen_hash((56, 43, 34, 78)))
self.assertEqual(47327, self.trm.owen_hash((50, 62, 78, 78)))
self.assertEqual(39238, self.trm.owen_hash((55, 48, 60, 58)))
self.assertEqual(13800, self.trm.owen_hash((48, 78, 78, 78)))
self.assertEqual(46941, self.trm.owen_hash((25, 56, 51, 48)))
self.assertEqual(64104, self.trm.owen_hash((24, 38, 73, 24)))
self.assertEqual(11410, self.trm.owen_hash((28, 62, 72, 2)))
self.assertEqual(233, self.trm.owen_hash((36, 46, 36, 58)))
self.assertIsInstance(self.trm.owen_hash((36, 46, 36, 58)), int)
def test_name2code(self) -> None:
self.assertEqual((21, 42, 28, 46), self.trm.name2code("A.LEN"))
self.assertEqual((56, 43, 34, 78), self.trm.name2code("SL.H"))
self.assertEqual((50, 62, 78, 78), self.trm.name2code("PV"))
self.assertEqual((55, 48, 60, 58), self.trm.name2code("R.OUT"))
self.assertEqual((48, 78, 78, 78), self.trm.name2code("O"))
self.assertEqual((25, 56, 51, 48), self.trm.name2code("C.SP.O"))
self.assertEqual((24, 38, 73, 24), self.trm.name2code("CJ-.C"))
self.assertEqual((28, 62, 72, 2), self.trm.name2code("EV-1"))
self.assertEqual((36, 46, 36, 58), self.trm.name2code("INIT"))
self.assertIsInstance(self.trm.name2code("INIT"), tuple)
def test_encode_frame(self) -> None:
self.assertEqual(b"#GHHGHUTIKGJI\r", self.trm.encode_frame((1, 16, 30, 210, 64, 50)))
self.assertEqual(b"#GHGHHUTIGGJKGK\r", self.trm.encode_frame((1, 1, 30, 210, 0, 52, 4)))
self.assertEqual(b"#GHHISOOGGGGGQSUR\r", self.trm.encode_frame((1, 18, 200, 128, 0, 0, 172, 235)))
self.assertEqual(b"#GHGJSOOGGGGGGGUQRK\r", self.trm.encode_frame((1, 3, 200, 128, 0, 0, 0, 234, 180)))
self.assertEqual(b"#GHHIPHGNGGGGKKPV\r", self.trm.encode_frame((1, 18, 145, 7, 0, 0, 68, 159)))
self.assertEqual(b"#GHGLPHGNKHSOGGGGGGJOMV\r", self.trm.encode_frame((1, 5, 145, 7, 65, 200, 0, 0, 0, 56, 111)))
self.assertEqual(b"#GHHGHIGJUIMK\r", self.trm.encode_frame((1, 16, 18, 3, 226, 100)))
self.assertEqual(b"#GHGHHIGJGGIHHO\r", self.trm.encode_frame((1, 1, 18, 3, 0, 33, 24)))
self.assertIsInstance(self.trm.encode_frame((1, 1, 18, 3, 0, 33, 24)), bytes)
def test_decode_frame(self) -> None:
self.assertEqual((1, 1, 30, 210, 0, 52, 4), self.trm.decode_frame(b"#GHGHHUTIGGJKGK\r"))
self.assertEqual((1, 3, 200, 128, 0, 0, 0, 234, 180), self.trm.decode_frame(b"#GHGJSOOGGGGGGGUQRK\r"))
self.assertEqual((1, 5, 57, 243, 0, 0, 0, 0, 0, 11, 51), self.trm.decode_frame(b"#GHGLJPVJGGGGGGGGGGGRJJ\r"))
self.assertEqual((1, 5, 225, 125, 195, 71, 230, 0, 0, 89, 223), self.trm.decode_frame(b"#GHGLUHNTSJKNUMGGGGLPTV\r"))
self.assertEqual((1, 8, 45, 91, 52, 48, 48, 48, 46, 51, 48, 86, 233, 155), self.trm.decode_frame(b"#GHGOITLRJKJGJGJGIUJJJGLMUPPR\r"))
self.assertEqual((1, 3, 180, 101, 0, 0, 0, 9, 1), self.trm.decode_frame(b"#GHGJRKMLGGGGGGGPGH\r"))
self.assertEqual((1, 3, 2, 51, 71, 180, 101, 87, 52), self.trm.decode_frame(b"#GHGJGIJJKNRKMLLNJK\r"))
self.assertEqual((1, 3, 2, 51, 71, 100, 234, 99, 78), self.trm.decode_frame(b"#GHGJGIJJKNMKUQMJKU\r"))
self.assertEqual((1, 1, 30, 37, 20, 126, 6), self.trm.decode_frame(b"#GHGHHUILHKNUGM\r"))
self.assertIsInstance(self.trm.decode_frame(b"#GHGHHUILHKNUGM\r"), tuple)
def test_pack_value(self) -> None:
self.assertEqual(bytes([194, 71, 255, 167, 15, 225]), self.trm.pack_value("F32+T", (-49.99966049194336, 4065)))
self.assertEqual(bytes([66, 246, 233, 223]), self.trm.pack_value("F32", 123.45678))
self.assertEqual(bytes([164, 14]), self.trm.pack_value("SDOT", -10.38))
self.assertEqual(bytes([29, 172]), self.trm.pack_value("SDOT", 350.0))
self.assertEqual(bytes([16, 16, 4]), self.trm.pack_value("SDOT", 410.0))
self.assertEqual(bytes([16]), self.trm.pack_value("SDOT", 0.0))
self.assertEqual(bytes([0]), self.trm.pack_value("DOT0", 0))
self.assertEqual(bytes([153]), self.trm.pack_value("DOT0", 99))
self.assertEqual(bytes([3, 4]), self.trm.pack_value("DOT0", 304))
self.assertEqual(bytes([9, 135, 101, 67, 33]), self.trm.pack_value("DOT0", 987654321))
self.assertEqual(bytes([66, 246, 233]), self.trm.pack_value("F24", 123.45678))
self.assertEqual(bytes([4, 210]), self.trm.pack_value("U16", 1234))
self.assertEqual(bytes([251, 46]), self.trm.pack_value("I16", -1234))
self.assertEqual(bytes([12]), self.trm.pack_value("U8", 12))
self.assertEqual(bytes([244]), self.trm.pack_value("I8", -12))
self.assertEqual(bytes([50, 48, 50, 204, 208, 210]), self.trm.pack_value("STR", "ТРМ202"))
self.assertEqual(b"", self.trm.pack_value("U8", None)) # if empty buffer
self.assertIsInstance(self.trm.pack_value("I8", -12), bytes)
def test_unpack_value(self) -> None:
self.assertEqual((-49.99966049194336, 4065), self.trm.unpack_value("F32+T", bytes([194, 71, 255, 167, 15, 225]), None))
self.assertEqual(123.45677947998047, self.trm.unpack_value("F32", bytes([66, 246, 233, 223]), None))
self.assertEqual(350.0, self.trm.unpack_value("SDOT", bytes([29, 172, 0, 0]), 0))
self.assertEqual(410.0, self.trm.unpack_value("SDOT", bytes([16, 16, 4, 0, 0]), 0))
self.assertEqual(350.0, self.trm.unpack_value("SDOT", bytes([29, 172]), None))
self.assertEqual(410.0, self.trm.unpack_value("SDOT", bytes([16, 16, 4]), None))
self.assertEqual(0.0, self.trm.unpack_value("SDOT", bytes([16, 0, 0]), 0))
self.assertEqual(0.0, self.trm.unpack_value("SDOT", bytes([16]), None))
self.assertEqual(0, self.trm.unpack_value("DOT0", bytes([0]), None))
self.assertEqual(99, self.trm.unpack_value("DOT0", bytes([153]), None))
self.assertEqual(304, self.trm.unpack_value("DOT0", bytes([3, 4]), None))
self.assertEqual(304, self.trm.unpack_value("DOT0", bytes([3, 4, 0, 0]), 0))
self.assertEqual(987654321, self.trm.unpack_value("DOT0", bytes([9, 135, 101, 67, 33]), None))
self.assertEqual(123.455078125, self.trm.unpack_value("F24", bytes([66, 246, 233]), None))
self.assertEqual((71, 46059), self.trm.unpack_value("U24", bytes([71, 179, 235]), None))
self.assertEqual(1234, self.trm.unpack_value("U16", bytes([4, 210]), None))
self.assertEqual(-1234, self.trm.unpack_value("I16", bytes([251, 46]), None))
self.assertEqual(12, self.trm.unpack_value("U8", bytes([12]), None))
self.assertEqual(-12, self.trm.unpack_value("I8", bytes([244]), None))
self.assertEqual("ТРМ202", self.trm.unpack_value("STR", bytes([50, 48, 50, 204, 208, 210]), None))
self.assertRaises(OwenError, lambda: self.trm.unpack_value("F32", bytes([253]), None)) # if error code
def test_make_packet(self) -> None:
self.assertEqual(b"#GHHGHUTIKGJI\r", self.trm.make_packet(1, "A.LEN", None, b""))
self.assertEqual(b"#GHHISOOGGGGGQSUR\r", self.trm.make_packet(1, "DON", 0, b""))
self.assertEqual(b"#GHGLJPVJGGGGGGGGGGGRJJ\r", self.trm.make_packet(0, "FB", 0, bytes([0, 0, 0])))
self.assertEqual(b"#GHGLUHNTSJKNUMGGGGLPTV\r", self.trm.make_packet(0, "SL.L", 0, bytes([195, 71, 230])))
self.assertEqual(b"#GHGHRNIUGGMJSQ\r", self.trm.make_packet(0, "SBIT", None, bytes([0])))
self.assertEqual(b"#GHGLPHGNKHSOGGGGGGJOMV\r", self.trm.make_packet(0, "SP", 0, bytes([65, 200, 0])))
self.assertEqual(b"#GHGHRNMGGORMUL\r", self.trm.make_packet(0, "BPS", None, bytes([8])))
self.assertEqual(b"#JIHIPHGNGGGGJHVJ\r", self.trm11.make_packet(1, "SP", 0, b""))
self.assertEqual(b"#JIGLPHGNKHRHPQGGGGUMHO\r", self.trm11.make_packet(0, "SP", 0, bytes([65, 177, 154])))
self.assertIsInstance(self.trm11.make_packet(0, "SP", 0, bytes([65, 177, 154])), bytes)
def test_parse_response(self) -> None:
self.assertEqual(bytes([0]), self.trm.parse_response(b"#GHHGHUTIKGJI\r", b"#GHGHHUTIGGJKGK\r"))
self.assertEqual(bytes([0, 0, 0]), self.trm.parse_response(b"#GHHISOOGGGGGQSUR\r", b"#GHGJSOOGGGGGGGUQRK\r"))
self.assertEqual(bytes([195, 71, 230, 0, 0]), self.trm.parse_response(b"#GHHIUHNTGGGGPULL\r", b"#GHGLUHNTSJKNUMGGGGLPTV\r"))
self.assertEqual(bytes([52, 48, 48, 48, 46, 51, 48, 86]), self.trm.parse_response(b"#GHHGITLRRKVN\r", b"#GHGOITLRJKJGJGJGIUJJJGLMUPPR\r"))
self.assertEqual(bytes([71, 180, 101]), self.trm.parse_response(b"#GHHGGIJJRIQN\r", b"#GHGJGIJJKNRKMLLNJK\r"))
self.assertEqual(bytes([100]), self.trm.parse_response(b"#GHHGJONIJKMN\r", b"#GHGHJONIMKKIMP\r"))
self.assertRaises(OwenError, lambda: self.trm.parse_response(b"#GHHGHUTIKGJI\r", b"")) # if empty message
self.assertRaises(OwenError, lambda: self.trm.parse_response(b"#GHHGHUTIKGJI\r", b"GHHGHUTIKGJI\r")) # if first byte not '#'
self.assertRaises(OwenError, lambda: self.trm.parse_response(b"#GHHGHUTIKGJI\r", b"#GHHGHUTIKGJI")) # if last byte not '\r'
self.assertRaises(OwenError, lambda: self.trm.parse_response(b"#GHHINNRQGGGGRUIR\r", b"#GHGJGIJJKNNNRQPUSV\r")) # if error code
self.assertRaises(OwenError, lambda: self.trm.parse_response(b"#GHHIUHNTGGGGPULL\r", b"#GHGLUHNTSJKNUMGGGGLPTD\r")) # if checksum error
self.assertRaises(OwenError, lambda: self.trm.parse_response(b"#GHHGROTVJNPQ\r", b"#IJKJGIJJJHKOKNIJTO\r")) # if addresses mismatch
self.assertIsInstance(self.trm.parse_response(b"#GHHGJONIJKMN\r", b"#GHGHJONIMKKIMP\r"), bytes)
self.assertIsInstance(self.trm.parse_response(b"#GHGLUHNTJVOGGGGGGGQGIG\r", b"#GHGLUHNTJVOGGGGGGGQGIG\r"), bytes)
if __name__ == "__main__":
unittest.main()