2e9272cc8a
引入成熟 IEC 60870-5-104 子站的只读子集(App/protocol/iec60870,28 个源文件 按原字节复制,UPSTREAM.sha256 记录来源,兼容补丁保留全部断言与容量),在其上 装配单属主共享核心(Start/Poll/Stop/Get_Status),并把标准 DTU 演示点表全量 接入为唯一真源。 - iec104_core:threadless 推进,poll 零等待,通知/交互/COV 扫描全部有界; 生命周期区分失败启动待重试、重复启动拒绝、断线保固化 RAM。 - iec104_dtu_table / iec104_source:标准 DTU 全点表注册,无数据源的点读 0, 遥控只做模拟状态可读回,不触碰实际出口。 - iec104_sim:仅窗口与独立服务模式起真实 TCP,无头黄金模式保持确定性假统计。 - test/host/iec104_dtu:独立真实 TCP 11 项、传输层 10 项、生命周期与借用负例。 验证:lvgl_sim 真实 TCP 11/11、传输 10/10,UI 像素回归未回退;AC5 单 TU 编译 0 错误 0 诊断。板端尚未切换:完整库闭包 RAM 超 92% 门禁净增预算 25730B, 结论为停止转实施,记录在 IEC104_MCU最小可行性验证.md。旧实现与 board 服务 保持原样,未提交 MDK 工程改动,未烧板。
365 lines
18 KiB
Python
365 lines
18 KiB
Python
"""Real-loopback acceptance against the same lvgl_sim binary as UI tests."""
|
|
import argparse
|
|
import datetime
|
|
import hashlib
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
import socket
|
|
import struct
|
|
import subprocess
|
|
import tempfile
|
|
import time
|
|
import traceback
|
|
|
|
from oracle import ROOT, reference
|
|
from wire import Client, asdu, cp56, header, objects, remote_objects, tlv, u24
|
|
|
|
|
|
class Acceptance:
|
|
def __init__(self, args):
|
|
self.args = args
|
|
self.oracle = reference()
|
|
self.trace, self.decoded, self.results = [], [], []
|
|
self.client = None
|
|
|
|
def connect(self):
|
|
if self.client:
|
|
self.client.close()
|
|
time.sleep(0.10) # Give the single-owner service one close/poll cycle.
|
|
self.client = Client(self.args.host, self.args.port, self.trace)
|
|
self.client.start(split=True)
|
|
return self.client
|
|
|
|
def run(self, name, function):
|
|
started = time.monotonic()
|
|
try:
|
|
self.connect()
|
|
function()
|
|
result = {"name": name, "passed": True}
|
|
except Exception as exc:
|
|
result = {"name": name, "passed": False, "error": str(exc), "traceback": traceback.format_exc()}
|
|
result["seconds"] = time.monotonic() - started
|
|
self.results.append(result)
|
|
print(("PASS " if result["passed"] else "FAIL ") + name + (": " + result["error"] if not result["passed"] else ""), flush=True)
|
|
if self.client:
|
|
self.client.close()
|
|
self.client = None
|
|
|
|
def read(self, ioa):
|
|
self.client.request(asdu(102, u24(ioa), cot=5))
|
|
data, _ = self.client.receive(lambda d: header(d)["cot"] == 5 or header(d)["pn"])
|
|
assert not header(data)["pn"], data.hex()
|
|
assert header(data)["ca"] == 1 and header(data)["oa"] == 17, data.hex()
|
|
rows = objects(data)
|
|
assert len(rows) == 1 and rows[0]["ioa"] == ioa
|
|
self.decoded.extend(rows)
|
|
return rows[0]
|
|
|
|
def remote_read(self, ioas=(), area=0):
|
|
self.client.request(asdu(202, struct.pack("<H", area) + b"".join(map(u24, ioas)), count=len(ioas)))
|
|
rows = []
|
|
while True:
|
|
data = self.client.response(202, 7)
|
|
assert int.from_bytes(data[6:8], "little") == area
|
|
assert data[8] in (0, 1), ("reserved PI flags", data.hex())
|
|
rows.extend(remote_objects(data))
|
|
if not data[8] & 1:
|
|
break
|
|
self.decoded.extend(rows)
|
|
assert len({row["ioa"] for row in rows}) == len(rows)
|
|
if ioas:
|
|
assert set(ioas) == {row["ioa"] for row in rows}
|
|
return {row["ioa"]: row for row in rows}
|
|
|
|
def preset(self, values, area=0, pn=False):
|
|
self.client.request(asdu(203, struct.pack("<H", area) + b"\x80" + b"".join(tlv(*v) for v in values), count=len(values)))
|
|
return self.client.response(203, 7, pn)
|
|
|
|
def finish(self, cancel=False, area=0, pn=False):
|
|
self.client.request(asdu(203, struct.pack("<H", area) + b"\x00", count=0, cot=8 if cancel else 6))
|
|
return self.client.response(203, 9 if cancel else 7, pn)
|
|
|
|
def test_link_start_stop_testfr_and_prestart(self):
|
|
self.client.close()
|
|
time.sleep(0.10)
|
|
self.client = Client(self.args.host, self.args.port, self.trace)
|
|
self.client.send(bytes.fromhex("680443000000"))
|
|
while self.client.frame()[2] != 0x83:
|
|
pass
|
|
self.client.request(asdu(100, u24(0) + bytes((20,))))
|
|
# Mature Link.c rejects pre-START I frames as FATAL and closes.
|
|
try:
|
|
while True:
|
|
frame = self.client.frame()
|
|
assert frame[2] & 1, ("business published before START", frame.hex())
|
|
except EOFError:
|
|
pass
|
|
self.connect()
|
|
self.client.send(bytes.fromhex("680443000000"))
|
|
while self.client.frame()[2] != 0x83:
|
|
pass
|
|
self.client.send(bytes.fromhex("680413000000"))
|
|
while self.client.frame()[2] != 0x23:
|
|
pass
|
|
self.client.send(bytes.fromhex("680443000000"))
|
|
while True:
|
|
frame = self.client.frame()
|
|
assert frame[2] & 1, ("I-frame while STOPPED", frame.hex())
|
|
if frame[2] == 0x83:
|
|
break
|
|
self.client.start()
|
|
self.client.request(asdu(201, u24(0)))
|
|
self.client.response(201, 7)
|
|
|
|
def test_gi_exact_set_and_zero_observations(self):
|
|
self.client.request(asdu(100, u24(0) + b"\x14"), split=True)
|
|
self.client.response(100, 7)
|
|
rows = []
|
|
while True:
|
|
data, _ = self.client.receive(lambda d: header(d)["cot"] in (20, 10))
|
|
if header(data)["type"] == 100:
|
|
assert header(data)["cot"] == 10 and not header(data)["pn"]
|
|
break
|
|
assert header(data)["cot"] == 20 and not header(data)["pn"]
|
|
rows.extend(objects(data))
|
|
self.decoded.extend(rows)
|
|
actual = {row["ioa"]: row["type"] for row in rows}
|
|
assert len(actual) == len(rows), "duplicate GI objects"
|
|
expected = self.oracle["gi"]
|
|
assert actual == expected, {"missing": sorted(expected.keys() - actual.keys()), "extra": sorted(actual.keys() - expected.keys()), "wrong_types": [ioa for ioa in actual.keys() & expected.keys() if actual[ioa] != expected[ioa]]}
|
|
assert all(row["value"] == 0 and row["quality"] == 128 for row in rows if row["type"] < 100), "source-less observation not zero+IV"
|
|
for row in rows:
|
|
if row["type"] >= 100:
|
|
group, index = divmod(row["ioa"] - 0x8601, 0x20)
|
|
expected_value = (200 if index < 4 else 655) if group == 0 else (-10000 if group == 1 else 10000 if group == 2 else 0)
|
|
assert row["value"] == expected_value and row["qpm"] == (1, 3, 4, 2)[group], row
|
|
|
|
def test_counter_exact_set_zero_and_invalid(self):
|
|
self.client.request(asdu(101, u24(0) + bytes((5,))))
|
|
self.client.response(101, 7)
|
|
rows = []
|
|
while True:
|
|
data, _ = self.client.receive(lambda d: header(d)["type"] in (15, 37, 206, 207, 101))
|
|
h = header(data)
|
|
assert h["ca"] == 1 and h["oa"] == 17 and not h["pn"]
|
|
if h["type"] == 101:
|
|
assert h["cot"] == 10
|
|
break
|
|
assert h["cot"] == 37
|
|
rows.extend(objects(data))
|
|
self.decoded.extend(rows)
|
|
assert len(rows) == len(self.oracle["counters"])
|
|
assert {r["ioa"] for r in rows} == set(self.oracle["counters"])
|
|
assert all(r["value"] == 0 and r["quality"] & 128 for r in rows)
|
|
|
|
def test_read_all_runtime_addresses(self):
|
|
for ioa, typ in sorted(self.oracle["read"].items()):
|
|
row = self.read(ioa)
|
|
assert row["type"] == typ, row
|
|
assert row["value"] == 0, row
|
|
assert row["quality"] == (32 if typ in (5, 7) else 128), row
|
|
|
|
def test_remote_complete_typed_snapshot(self):
|
|
actual = self.remote_read()
|
|
expected = self.oracle["remote"]
|
|
assert set(actual) == set(expected), {"missing": sorted(expected.keys() - actual.keys()), "extra": sorted(actual.keys() - expected.keys())}
|
|
for ioa, (tag, text) in expected.items():
|
|
row = actual[ioa]
|
|
assert row["tag"] == tag, row
|
|
value = text if tag == 4 else float(text) if tag == 38 else int(text)
|
|
assert math.isclose(row["value"], value, rel_tol=1e-6, abs_tol=1e-7) if tag == 38 else row["value"] == value, row
|
|
|
|
def test_area_switch_and_readback(self):
|
|
for area in (1, 4, 0):
|
|
self.client.request(asdu(200, u24(0) + struct.pack("<H", area)))
|
|
self.client.response(200, 7)
|
|
self.client.request(asdu(201, u24(0)))
|
|
reply = self.client.response(201, 7)
|
|
assert len(reply) == 15 and reply[6:9] == u24(0)
|
|
assert struct.unpack("<HHH", reply[9:]) == (area, 0, 4)
|
|
self.client.request(asdu(200, u24(0) + struct.pack("<H", 5)))
|
|
self.client.response(200, 7, True)
|
|
self.client.request(asdu(201, u24(0)))
|
|
assert self.client.response(201, 7)[9:11] == b"\x00\x00"
|
|
|
|
def test_typed_preset_commit_cancel_readback(self):
|
|
addresses = (0x8820, 0x8823, 0x882D, 0x802E)
|
|
before = self.remote_read(addresses)
|
|
change = [(0x8820, 1, 0), (0x8823, 38, 8.25), (0x882D, 45, 2), (0x802E, 35, 16777217)]
|
|
original = [(ioa, before[ioa]["tag"], before[ioa]["value"]) for ioa in addresses]
|
|
try:
|
|
self.preset(change)
|
|
assert self.remote_read(addresses) == before, "preset leaked into active values"
|
|
self.finish()
|
|
after = self.remote_read(addresses)
|
|
assert all(after[ioa]["tag"] == tag and after[ioa]["value"] == value for ioa, tag, value in change)
|
|
self.connect()
|
|
assert self.remote_read(addresses) == after, "TCP reconnect lost committed RAM values"
|
|
self.preset(original)
|
|
self.connect()
|
|
self.finish(pn=True)
|
|
assert self.remote_read(addresses) == after, "disconnected stage became active"
|
|
self.preset(original)
|
|
self.finish(cancel=True)
|
|
assert self.remote_read(addresses) == after, "cancel published stage"
|
|
self.finish(pn=True)
|
|
finally:
|
|
self.preset(original)
|
|
self.finish()
|
|
assert self.remote_read(addresses) == before
|
|
|
|
def test_unknown_and_bad_typed_requests(self):
|
|
self.client.request(asdu(102, u24(0xFFFFFF), cot=5))
|
|
self.client.response(102, 47, True)
|
|
for ioa in (0xFFFFFF, 0x9601):
|
|
self.client.request(asdu(202, b"\x00\x00" + u24(ioa)))
|
|
self.client.response(202, 47, True)
|
|
for value in ([(0x8820, 1, 2)], [(0x8823, 45, 8)], [(0x8823, 38, float("nan"))]):
|
|
self.preset(value, pn=True)
|
|
self.finish(cancel=True)
|
|
|
|
def test_maximum_apdu_and_coalesced_frames(self):
|
|
# Structurally valid 249-byte ASDU, unknown IOA, String235. Business must respond.
|
|
request = asdu(203, b"\x00\x00\x80" + u24(0xFFFFFF) + bytes((4, 235)) + b"X" * 235)
|
|
frame = self.client.pack(request)
|
|
assert len(frame) == 255 and frame[1] == 253 and len(request) == 249
|
|
self.client.send(frame, split=True)
|
|
reply = self.client.response(203, 47, True)
|
|
assert reply
|
|
self.finish(cancel=True)
|
|
first = self.client.pack(asdu(201, u24(0)))
|
|
second = self.client.pack(asdu(201, u24(0)))
|
|
self.client.send(first + second)
|
|
self.client.response(201, 7)
|
|
self.client.response(201, 7)
|
|
|
|
def command(self, value, select=False, ioa=0x6002, pn=False):
|
|
self.client.request(asdu(46, u24(ioa) + bytes((value | (128 if select else 0),))))
|
|
return self.client.response(46, 7, pn)
|
|
|
|
def position(self):
|
|
return tuple(self.read(ioa)["value"] for ioa in (0x1001, 0x0011, 0x0028))
|
|
|
|
def execute_with_feedback(self, value):
|
|
before = self.position()
|
|
self.command(value, select=True)
|
|
assert self.position() == before, "selection acted"
|
|
start = len(self.client.asdus)
|
|
self.command(value)
|
|
self.client.receive(lambda d: header(d)["type"] == 46 and header(d)["cot"] == 10)
|
|
frames = self.client.asdus[start:]
|
|
rows = [r for d in frames if header(d)["type"] in (1, 3, 30, 31) for r in objects(d)]
|
|
self.decoded.extend(rows)
|
|
expected = (value, int(value == 2), int(value == 1))
|
|
assert before != expected, "test must request a real state transition"
|
|
assert self.position() == expected
|
|
for ioa, result in zip((0x1001, 0x0011, 0x0028), expected):
|
|
assert any(r["ioa"] == ioa and r["value"] == result and r["quality"] == 32 for r in rows), ("missing simulated feedback", ioa, rows)
|
|
|
|
def test_sbo_order_feedback_and_reconnect(self):
|
|
initial = self.position()
|
|
self.command(2, pn=True)
|
|
assert self.position() == initial
|
|
self.command(2, select=True)
|
|
self.command(1, pn=True)
|
|
assert self.position() == initial
|
|
self.command(2, select=True)
|
|
self.command(2, ioa=0x6004, pn=True)
|
|
assert self.position() == initial
|
|
self.connect() # Wrong-IOA EXEC does not cancel the original selection.
|
|
self.execute_with_feedback(1 if initial[0] == 2 else 2)
|
|
after = self.position()
|
|
self.command(after[0], pn=True)
|
|
assert self.position() == after
|
|
opposite = 1 if after[0] == 2 else 2
|
|
self.command(opposite, select=True)
|
|
self.connect()
|
|
self.command(opposite, pn=True)
|
|
assert self.position() == after, "old connection selection survived"
|
|
self.client.request(asdu(46, u24(0x6002) + bytes((opposite | 128,)), ca=2))
|
|
reply, _ = self.client.receive(lambda d: header(d)["type"] == 46)
|
|
assert header(reply)["cot"] == 46 and header(reply)["pn"]
|
|
self.command(opposite, pn=True)
|
|
assert self.position() == after, "wrong CA acted or selected"
|
|
self.execute_with_feedback(opposite)
|
|
|
|
def test_clock_is_device_only_and_sbo_is_monotonic(self):
|
|
host_delta = time.time() - time.monotonic()
|
|
self.command(2, select=True)
|
|
# Year2035 is deliberately far from the host clock; no OS clock API is used.
|
|
stamp = struct.pack("<HBBBBB", 12345, 22, 11, 17, 6, 35)
|
|
self.client.request(asdu(103, u24(0) + stamp))
|
|
self.client.response(103, 7)
|
|
self.client.request(asdu(103, u24(0) + bytes(7), cot=5))
|
|
reply = self.client.response(103, 5)
|
|
actual_time = cp56(reply[-7:])
|
|
assert not actual_time["invalid"] and not actual_time["summer"]
|
|
requested_time = datetime.datetime(2035, 6, 17, 11, 22, 12, 345000)
|
|
assert 0 <= (datetime.datetime.fromisoformat(actual_time["iso"]) - requested_time).total_seconds() < 2
|
|
time.sleep(0.15)
|
|
self.client.request(asdu(103, u24(0) + bytes(7), cot=5))
|
|
later = cp56(self.client.response(103, 5)[-7:])
|
|
assert 0.1 <= (datetime.datetime.fromisoformat(later["iso"]) - datetime.datetime.fromisoformat(actual_time["iso"])).total_seconds() < 2
|
|
assert abs((time.time() - time.monotonic()) - host_delta) < 1.0, "host wall clock changed"
|
|
# A far-future device clock must not prematurely expire the selection.
|
|
self.command(2)
|
|
self.client.receive(lambda d: header(d)["type"] == 46 and header(d)["cot"] == 10)
|
|
self.command(1, select=True)
|
|
time.sleep(self.args.sbo_timeout + 0.3)
|
|
self.command(1, pn=True)
|
|
assert self.read(0x1001)["value"] == 2, "expired command changed state"
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--exe", type=Path)
|
|
parser.add_argument("--host", default="127.0.0.1")
|
|
parser.add_argument("--port", type=int, default=24040)
|
|
parser.add_argument("--sbo-timeout", type=float, default=30)
|
|
parser.add_argument("--output", type=Path, default=ROOT / "ci-artifacts" / "iec104-tests")
|
|
parser.add_argument("--only", default="")
|
|
args = parser.parse_args()
|
|
args.output.mkdir(parents=True, exist_ok=True)
|
|
suite = Acceptance(args)
|
|
process, log = None, None
|
|
binary = {}
|
|
with tempfile.TemporaryDirectory(prefix="iec104-dtu-") as cwd:
|
|
try:
|
|
if args.exe:
|
|
exe = args.exe.resolve()
|
|
binary = {"path": str(exe), "sha256": hashlib.sha256(exe.read_bytes()).hexdigest()}
|
|
log = (args.output / "simulator.log").open("w", encoding="utf-8")
|
|
process = subprocess.Popen([str(exe), "--iec104", "--iec104-headless", "--iec104-port", str(args.port), "--iec104-duration", "180"], cwd=cwd, stdout=log, stderr=subprocess.STDOUT)
|
|
deadline = time.monotonic() + 15
|
|
while True:
|
|
if process.poll() is not None:
|
|
raise RuntimeError("simulator exited before listen: " + str(process.returncode))
|
|
try:
|
|
with socket.create_connection((args.host, args.port), 0.2):
|
|
break
|
|
except OSError:
|
|
if time.monotonic() >= deadline:
|
|
raise TimeoutError("simulator did not listen")
|
|
time.sleep(0.05)
|
|
names = ["test_link_start_stop_testfr_and_prestart", "test_gi_exact_set_and_zero_observations", "test_counter_exact_set_zero_and_invalid", "test_read_all_runtime_addresses", "test_remote_complete_typed_snapshot", "test_area_switch_and_readback", "test_typed_preset_commit_cancel_readback", "test_unknown_and_bad_typed_requests", "test_maximum_apdu_and_coalesced_frames", "test_sbo_order_feedback_and_reconnect", "test_clock_is_device_only_and_sbo_is_monotonic"]
|
|
for name in names:
|
|
if not args.only or args.only in name:
|
|
suite.run(name, getattr(suite, name))
|
|
finally:
|
|
if process and process.poll() is None:
|
|
process.terminate()
|
|
process.wait(timeout=10)
|
|
if log:
|
|
log.close()
|
|
report = {"created": datetime.datetime.now(datetime.timezone.utc).isoformat(), "binary": binary, "reference": suite.oracle, "results": suite.results,
|
|
"limitations": ["Service-side short-write/WOULD_BLOCK requires separate transport unit evidence", "No-physical-DO requires source/build audit in addition to TCP feedback", "TCP process is terminated by harness after tests"]}
|
|
(args.output / "report.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
|
|
(args.output / "wire.json").write_text(json.dumps(suite.trace, indent=2), encoding="utf-8")
|
|
(args.output / "objects.json").write_text(json.dumps(suite.decoded, indent=2), encoding="utf-8")
|
|
return 0 if suite.results and all(row["passed"] for row in suite.results) else 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|