400 lines
16 KiB
Python
400 lines
16 KiB
Python
from __future__ import annotations
|
|
|
|
from datetime import datetime
|
|
from typing import Dict, List, Sequence, Tuple
|
|
|
|
from app.adapters.device_client import (
|
|
AI_ALARM_START_REGISTER,
|
|
AI_CHANNEL_START_REGISTER,
|
|
AI_INPUT_COUNT,
|
|
AI_INPUT_START_REGISTER,
|
|
AO_CHANNEL_START_REGISTER,
|
|
CDeviceClient,
|
|
DI_INPUT_REGISTER,
|
|
DO_INPUT_REGISTER,
|
|
DO_STATE_REGISTER,
|
|
EVENT_FLAG_REGISTER,
|
|
EVENT_INPUT_START_REGISTER,
|
|
EVENT_SUCCESS_REPLY_REGISTER,
|
|
STATUS_WORD_00E6_REGISTER,
|
|
STATUS_WORD_00E7_REGISTER,
|
|
NET_CONFIG_REGISTER_COUNT,
|
|
NET_CONFIG_START_REGISTER,
|
|
LINE_ALARM_REGISTERS_PER_LINE,
|
|
LINE_ALARM_START_REGISTER,
|
|
LINE_START_REGISTERS,
|
|
ModbusTransport,
|
|
TIME_SYNC_START_REGISTER,
|
|
UART_CONFIG_REGISTER_COUNT,
|
|
UART_CONFIG_START_REGISTER,
|
|
VALUE_GROUP_FIELDS,
|
|
)
|
|
from app.schemas.platform import (
|
|
AiAlarmSettingIn,
|
|
AlarmRule,
|
|
ChannelConfigIn,
|
|
ChannelItem,
|
|
DeviceConfigIn,
|
|
LineAlarmSettingIn,
|
|
NetConfigItem,
|
|
SoftwareVersion,
|
|
HardwareVersion,
|
|
SwitchControlIn,
|
|
SystemConfigIn,
|
|
TimeSyncConfigIn,
|
|
UartConfigItem,
|
|
)
|
|
|
|
|
|
class FakeTransport(ModbusTransport):
|
|
def __init__(self) -> None:
|
|
self.input_registers: Dict[int, int] = {}
|
|
self.holding_registers: Dict[int, int] = {}
|
|
self.discrete_inputs: Dict[int, bool] = {}
|
|
self.coils: Dict[int, bool] = {}
|
|
self.written_registers: List[Tuple[int, List[int]]] = []
|
|
self.written_coils: List[Tuple[int, bool]] = []
|
|
|
|
def set_input_block(self, address: int, values: Sequence[int]) -> None:
|
|
for offset, value in enumerate(values):
|
|
self.input_registers[address + offset] = int(value)
|
|
|
|
def set_holding_block(self, address: int, values: Sequence[int]) -> None:
|
|
for offset, value in enumerate(values):
|
|
self.holding_registers[address + offset] = int(value)
|
|
|
|
def set_discrete_block(self, address: int, values: Sequence[bool]) -> None:
|
|
for offset, value in enumerate(values):
|
|
self.discrete_inputs[address + offset] = bool(value)
|
|
|
|
def set_coil_block(self, address: int, values: Sequence[bool]) -> None:
|
|
for offset, value in enumerate(values):
|
|
self.coils[address + offset] = bool(value)
|
|
|
|
def read_input_registers(self, address: int, count: int) -> List[int]:
|
|
return [self.input_registers.get(address + offset, 0) for offset in range(count)]
|
|
|
|
def read_holding_registers(self, address: int, count: int) -> List[int]:
|
|
return [self.holding_registers.get(address + offset, 0) for offset in range(count)]
|
|
|
|
def read_discrete_inputs(self, address: int, count: int) -> List[bool]:
|
|
return [self.discrete_inputs.get(address + offset, False) for offset in range(count)]
|
|
|
|
def read_coils(self, address: int, count: int) -> List[bool]:
|
|
return [self.coils.get(address + offset, False) for offset in range(count)]
|
|
|
|
def write_registers(self, address: int, values: Sequence[int]) -> None:
|
|
block = [int(value) for value in values]
|
|
self.written_registers.append((address, block))
|
|
for offset, value in enumerate(block):
|
|
self.holding_registers[address + offset] = value
|
|
|
|
def write_coil(self, address: int, value: bool) -> None:
|
|
self.written_coils.append((address, bool(value)))
|
|
self.coils[address] = bool(value)
|
|
|
|
|
|
def test_modbus_client_reads_upstream_data() -> None:
|
|
transport = FakeTransport()
|
|
client = CDeviceClient(transport=transport)
|
|
|
|
for line_index, start_register in enumerate(LINE_START_REGISTERS, start=1):
|
|
values: List[int] = []
|
|
base = float(line_index * 100)
|
|
for field_offset, _field_name in enumerate(VALUE_GROUP_FIELDS, start=1):
|
|
values.extend(client._float_to_registers(base + field_offset))
|
|
transport.set_input_block(start_register, values)
|
|
|
|
ai_values: List[int] = []
|
|
for index in range(AI_INPUT_COUNT):
|
|
ai_values.extend(client._float_to_registers(1.25 + index))
|
|
transport.set_input_block(AI_INPUT_START_REGISTER, ai_values)
|
|
transport.set_discrete_block(0x0000, [True, False, True, False, True, False, True, False, True, False, True, False])
|
|
transport.set_input_block(DO_INPUT_REGISTER, [0x0AAA])
|
|
transport.set_input_block(DI_INPUT_REGISTER, [0x0555])
|
|
|
|
realtime = client.read_realtime_data()
|
|
|
|
assert len(realtime.line_list) == 4
|
|
assert realtime.line_list[0].sec_val.Ua == 101.0
|
|
assert realtime.line_list[1].sec_val.Pt == 210.0
|
|
assert realtime.line_list[3].sec_val.frq == 426.0
|
|
assert realtime.ai_collect["ai1"] == 1.25
|
|
assert realtime.ai_collect["ai8"] == 8.25
|
|
assert realtime.ai_collect["ai9"] == 0.0
|
|
assert realtime.switch["di1"] == 1
|
|
assert realtime.switch["di2"] == 0
|
|
assert realtime.switch["do1"] == 0
|
|
assert realtime.switch["do2"] == 1
|
|
|
|
|
|
def test_modbus_client_reads_alarm_event_once() -> None:
|
|
transport = FakeTransport()
|
|
client = CDeviceClient(transport=transport)
|
|
timestamp = int(datetime(2026, 5, 25, 12, 0, 0).timestamp())
|
|
|
|
transport.set_input_block(EVENT_FLAG_REGISTER, [1])
|
|
transport.set_input_block(
|
|
EVENT_INPUT_START_REGISTER,
|
|
[
|
|
timestamp & 0xFFFF,
|
|
(timestamp >> 16) & 0xFFFF,
|
|
123,
|
|
(2 << 12) | (1 << 8) | 1,
|
|
456,
|
|
],
|
|
)
|
|
|
|
alarms = client.read_alarm_events()
|
|
duplicate = client.read_alarm_events()
|
|
|
|
assert len(alarms) == 1
|
|
assert alarms[0].line_code == 2
|
|
assert alarms[0].event_type == 1
|
|
assert alarms[0].event_code == 1
|
|
assert alarms[0].event_value == 456
|
|
assert "线路2PT断线" in alarms[0].content
|
|
assert duplicate == []
|
|
assert transport.written_registers[-1] == (EVENT_SUCCESS_REPLY_REGISTER, [1])
|
|
|
|
|
|
def test_modbus_client_reads_alarm_events_until_event_flag_clears() -> None:
|
|
class CyclingTransport(FakeTransport):
|
|
def __init__(self, batches: List[List[int]]) -> None:
|
|
super().__init__()
|
|
self._batches = [list(batch) for batch in batches]
|
|
|
|
def read_input_registers(self, address: int, count: int) -> List[int]:
|
|
if address == EVENT_FLAG_REGISTER and count == 1:
|
|
return [len(self._batches[0]) // 5 if self._batches else 0]
|
|
if address == EVENT_INPUT_START_REGISTER:
|
|
return list(self._batches[0])[:count] if self._batches else [0] * count
|
|
return super().read_input_registers(address, count)
|
|
|
|
def write_registers(self, address: int, values: Sequence[int]) -> None:
|
|
super().write_registers(address, values)
|
|
if address == EVENT_SUCCESS_REPLY_REGISTER and self._batches:
|
|
self._batches.pop(0)
|
|
|
|
timestamp1 = int(datetime(2026, 5, 25, 12, 0, 0).timestamp())
|
|
timestamp2 = int(datetime(2026, 5, 25, 12, 0, 1).timestamp())
|
|
transport = CyclingTransport(
|
|
batches=[
|
|
[
|
|
timestamp1 & 0xFFFF,
|
|
(timestamp1 >> 16) & 0xFFFF,
|
|
111,
|
|
(1 << 12) | (3 << 8) | 1,
|
|
230,
|
|
],
|
|
[
|
|
timestamp2 & 0xFFFF,
|
|
(timestamp2 >> 16) & 0xFFFF,
|
|
222,
|
|
(2 << 12) | (2 << 8) | 7,
|
|
1,
|
|
],
|
|
]
|
|
)
|
|
client = CDeviceClient(transport=transport)
|
|
|
|
alarms = client.read_alarm_events()
|
|
|
|
assert len(alarms) == 2
|
|
assert alarms[0].line_code == 1
|
|
assert alarms[0].event_type == 3
|
|
assert alarms[1].line_code == 2
|
|
assert alarms[1].event_type == 2
|
|
assert transport.written_registers[-2:] == [
|
|
(EVENT_SUCCESS_REPLY_REGISTER, [1]),
|
|
(EVENT_SUCCESS_REPLY_REGISTER, [1]),
|
|
]
|
|
assert client.read_alarm_events() == []
|
|
|
|
|
|
def test_modbus_client_reads_status_words() -> None:
|
|
transport = FakeTransport()
|
|
client = CDeviceClient(transport=transport)
|
|
|
|
transport.set_input_block(EVENT_FLAG_REGISTER, [3])
|
|
transport.set_input_block(STATUS_WORD_00E6_REGISTER, [0x8A05])
|
|
transport.set_input_block(STATUS_WORD_00E7_REGISTER, [0x000E])
|
|
|
|
status = client.read_device_status()
|
|
|
|
assert status.event_count == 3
|
|
assert status.self_check == "异常"
|
|
assert status.net1 == "正常"
|
|
assert status.net2 == "断开"
|
|
assert status.net3 == "正常"
|
|
assert status.net4 == "断开"
|
|
assert status.uart1 == "断开"
|
|
assert status.uart2 == "正常"
|
|
assert status.uart3 == "断开"
|
|
assert status.uart4 == "正常"
|
|
assert status.frequency_limit == "越限"
|
|
assert status.ct_break == "断线"
|
|
assert status.pt_break == "断线"
|
|
assert status.status_word_00e6 == 0x8A05
|
|
assert status.status_word_00e7 == 0x000E
|
|
|
|
|
|
def test_modbus_client_reads_and_writes_downstream_registers() -> None:
|
|
transport = FakeTransport()
|
|
client = CDeviceClient(transport=transport)
|
|
|
|
ai_channel_payload = client._bytes_to_registers(
|
|
bytes(
|
|
[
|
|
0, 1, 0, 20, 0,
|
|
1, 2, 7, 8, 1,
|
|
]
|
|
+ [0] * 50
|
|
)
|
|
)
|
|
ao_channel_payload = client._bytes_to_registers(
|
|
bytes(
|
|
[
|
|
1, 1, 6, 10, 2,
|
|
]
|
|
+ [0] * 55
|
|
)
|
|
)
|
|
line_alarm_payload_bytes = bytes(
|
|
[
|
|
180, 5, 1, 1,
|
|
200, 6, 2, 0,
|
|
20, 7, 3, 1,
|
|
30, 8, 4, 0,
|
|
50, 9, 5, 1,
|
|
0, 10, 6, 1,
|
|
0, 11, 7, 0,
|
|
]
|
|
) + (10).to_bytes(2, "big") + (20).to_bytes(2, "big")
|
|
ai_alarm_payload_bytes = bytes(
|
|
[
|
|
20, 0, 3, 1, 1,
|
|
]
|
|
+ [0] * 55
|
|
)
|
|
net_payload_bytes = bytes(
|
|
[
|
|
192, 168, 1, 10, 255, 255, 255, 0, 192, 168, 1, 1, 1, 0,
|
|
10, 0, 0, 2, 255, 255, 255, 0, 10, 0, 0, 1, 1, 0,
|
|
]
|
|
+ [0] * 28
|
|
)
|
|
timestamp = int(datetime(2026, 5, 25, 12, 34, 56).timestamp())
|
|
|
|
transport.set_holding_block(AI_CHANNEL_START_REGISTER, ai_channel_payload)
|
|
transport.set_holding_block(AO_CHANNEL_START_REGISTER, ao_channel_payload)
|
|
transport.set_holding_block(
|
|
LINE_ALARM_START_REGISTER + LINE_ALARM_REGISTERS_PER_LINE,
|
|
client._bytes_to_registers(line_alarm_payload_bytes),
|
|
)
|
|
transport.set_holding_block(AI_ALARM_START_REGISTER, client._bytes_to_registers(ai_alarm_payload_bytes))
|
|
transport.set_holding_block(NET_CONFIG_START_REGISTER, client._bytes_to_registers(net_payload_bytes))
|
|
transport.set_holding_block(TIME_SYNC_START_REGISTER, [timestamp & 0xFFFF, (timestamp >> 16) & 0xFFFF])
|
|
|
|
device_payload = DeviceConfigIn(
|
|
password="",
|
|
hardware_version=HardwareVersion(),
|
|
software_version=SoftwareVersion(),
|
|
net=[NetConfigItem(nic="网卡一", ip="192.168.1.10", mask="255.255.255.0", gateway="192.168.1.1", protocol="Modbus TCP")],
|
|
uart=[
|
|
UartConfigItem(port="COM1", baud=9600, parity="NONE", data_bits=8, stop_bits=1, protocol="Modbus RTU"),
|
|
UartConfigItem(port="COM2", baud=115200, parity="EVEN", data_bits=8, stop_bits=2, protocol="Modbus RTU"),
|
|
],
|
|
)
|
|
channel_payload = ChannelConfigIn(
|
|
ai_channel=[ChannelItem(ch=1, singal_type="4-20mA", line_no=1, type="UA", limit_low=0, limit_high=20)],
|
|
ao_channel=[ChannelItem(ch=2, singal_type="1~5V", line_no=2, type="Q", limit_low=1, limit_high=8)],
|
|
)
|
|
line_alarm_payload = LineAlarmSettingIn(
|
|
line_no=2,
|
|
over_limit_alarm=[
|
|
AlarmRule(category="电压", limit=180, delay=5, output_node="开出1", enabled=True),
|
|
AlarmRule(category="电流", limit=200, delay=6, output_node="开出2", enabled=False),
|
|
AlarmRule(category="差流", limit=20, delay=7, output_node="开出3", enabled=True),
|
|
AlarmRule(category="功率", limit=30, delay=8, output_node="开出4", enabled=False),
|
|
AlarmRule(category="频率", limit=50, delay=9, output_node="开出5", enabled=True),
|
|
],
|
|
fault_alarm=[
|
|
AlarmRule(category="PT断线", delay=10, output_node="开出6", enabled=True),
|
|
AlarmRule(category="CT断线", delay=11, output_node="开出7", enabled=False),
|
|
],
|
|
)
|
|
ai_alarm_payload = [
|
|
AiAlarmSettingIn(
|
|
channel_no=1,
|
|
singal_type="4-20mA",
|
|
limit_low=0,
|
|
limit_high=20,
|
|
delay=3,
|
|
output_node="开出1",
|
|
enabled=True,
|
|
).model_dump()
|
|
]
|
|
system_payload = SystemConfigIn(time_sync="2026-05-25 12:34:56", brightness=80, screen_saver=60)
|
|
switch_payload = SwitchControlIn(ch=3, action=1)
|
|
|
|
read_channel = client.read_channel_config()
|
|
read_line_alarm = client.read_line_alarm_setting(2)
|
|
read_ai_alarm = client.read_ai_alarm_setting()
|
|
read_system = client.read_system_config()
|
|
read_time_sync = client.read_time_sync_config()
|
|
read_net = client.read_net_config("网卡二")
|
|
device_result = client.send_device_config(device_payload)
|
|
net_result = client.send_net_config(NetConfigItem(nic="网卡一", ip="172.16.1.10", mask="255.255.0.0", gateway="172.16.0.1", protocol="Modbus TCP"))
|
|
channel_result = client.send_channel_config(channel_payload)
|
|
line_result = client.send_line_alarm_setting(line_alarm_payload)
|
|
ai_alarm_result = client.send_ai_alarm_setting(ai_alarm_payload)
|
|
system_result = client.send_system_config(system_payload)
|
|
time_sync_result = client.send_time_sync_config(TimeSyncConfigIn(time_sync="2026-05-25 13:45:00"))
|
|
control_result = client.send_switch_control(switch_payload)
|
|
|
|
register_map = {address: values for address, values in transport.written_registers}
|
|
|
|
assert UART_CONFIG_START_REGISTER in register_map
|
|
assert len(register_map[UART_CONFIG_START_REGISTER]) == UART_CONFIG_REGISTER_COUNT
|
|
assert read_channel["ai_channel"][0]["singal_type"] == "4-20mA"
|
|
assert read_channel["ao_channel"][0]["type"] == "P"
|
|
assert read_line_alarm["line_no"] == 2
|
|
assert read_line_alarm["transformer_change"][0]["value"] == 10.0
|
|
assert read_line_alarm["transformer_change"][1]["value"] == 20.0
|
|
assert read_ai_alarm[0]["channel_no"] == 1
|
|
assert read_ai_alarm[0]["delay"] == 3
|
|
assert read_system["time_sync"] == "2026-05-25 12:34:56"
|
|
assert read_time_sync["time_sync"] == "2026-05-25 12:34:56"
|
|
assert read_net["nic"] == "网卡二"
|
|
assert read_net["ip"] == "10.0.0.2"
|
|
assert read_net["gateway"] == "10.0.0.1"
|
|
|
|
assert AI_CHANNEL_START_REGISTER in register_map
|
|
assert len(register_map[AI_CHANNEL_START_REGISTER]) == 30
|
|
assert AO_CHANNEL_START_REGISTER in register_map
|
|
assert len(register_map[AO_CHANNEL_START_REGISTER]) == 30
|
|
assert LINE_ALARM_START_REGISTER + LINE_ALARM_REGISTERS_PER_LINE in register_map
|
|
assert len(register_map[LINE_ALARM_START_REGISTER + LINE_ALARM_REGISTERS_PER_LINE]) == 16
|
|
assert AI_ALARM_START_REGISTER in register_map
|
|
assert len(register_map[AI_ALARM_START_REGISTER]) == 30
|
|
assert NET_CONFIG_START_REGISTER in register_map
|
|
assert len(register_map[NET_CONFIG_START_REGISTER]) == NET_CONFIG_REGISTER_COUNT
|
|
assert TIME_SYNC_START_REGISTER in register_map
|
|
assert len(register_map[TIME_SYNC_START_REGISTER]) == 2
|
|
assert DO_STATE_REGISTER in register_map
|
|
assert register_map[DO_STATE_REGISTER][0] == 0b100
|
|
assert transport.written_coils == [(2, True)]
|
|
|
|
assert device_result["send_status"] == "成功"
|
|
assert net_result["target"] == "net"
|
|
assert net_result["nic"] == "网卡一"
|
|
assert channel_result["modbus_written"]["ai_registers"] == 30
|
|
assert line_result["line_no"] == 2
|
|
assert ai_alarm_result["items"] == 1
|
|
assert system_result["send_status"] == "成功"
|
|
assert "brightness" in system_result["ignored_fields"]
|
|
assert time_sync_result["target"] == "time_sync"
|
|
assert time_sync_result["time_sync"] == "2026-05-25 13:45:00"
|
|
assert "执行成功" in control_result["control_status"]
|