Files
STM32F4-Base/IEC60870-Slave/test/energy_freeze_loopback_test.cjs
T
STF bdcc8b6500
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s
添加遥控、参数装载、文件传输等业务
2026-11-16 22:19:17 -08:00

220 lines
11 KiB
JavaScript

/* Independent IEC104 master: Annex B energy files, current values and restart.
* Artifacts remain below IEC60870-Slave/.build. No host clock is changed. */
'use strict';
const assert = require('node:assert/strict');
const net = require('node:net');
const fs = require('node:fs');
const path = require('node:path');
const { spawn, spawnSync } = require('node:child_process');
const { once } = require('node:events');
const { setTimeout: delay } = require('node:timers/promises');
const executable = process.argv[2];
if (!executable) throw new Error('Usage: node energy_freeze_loopback_test.cjs <example.exe>');
const project = path.resolve(__dirname, '..');
fs.mkdirSync(path.join(project, '.build'), { recursive: true });
const store = fs.mkdtempSync(path.join(project, '.build', 'energy-loopback-'));
class Master {
constructor(socket) {
this.socket = socket; this.buffer = Buffer.alloc(0); this.frames = [];
this.waiters = []; this.ns = 0; this.nr = 0;
socket.on('data', bytes => {
this.buffer = Buffer.concat([this.buffer, bytes]);
try {
while (this.buffer.length >= 2) {
assert.equal(this.buffer[0], 0x68);
const size = this.buffer[1] + 2; assert(size >= 6 && size <= 255);
if (this.buffer.length < size) break;
const frame = this.buffer.subarray(0, size); this.buffer = this.buffer.subarray(size);
const waiter = this.waiters.shift();
if (waiter) { clearTimeout(waiter.timer); waiter.resolve(frame); }
else this.frames.push(frame);
}
} catch (e) { this.fail(e); }
});
socket.on('error', e => this.fail(e));
socket.on('close', () => this.fail(new Error('TCP closed')));
}
fail(e) {
this.error = e;
for (const w of this.waiters.splice(0)) { clearTimeout(w.timer); w.reject(e); }
}
next() {
if (this.frames.length) return Promise.resolve(this.frames.shift());
if (this.error) return Promise.reject(this.error);
return new Promise((resolve, reject) => {
const w = { resolve, reject };
w.timer = setTimeout(() => {
this.waiters.splice(this.waiters.indexOf(w), 1); reject(new Error('TCP timeout'));
}, 15000);
this.waiters.push(w);
});
}
send(asdu) {
const frame = Buffer.alloc(asdu.length + 6); frame[0] = 0x68; frame[1] = asdu.length + 4;
frame.writeUInt16LE(this.ns++ << 1, 2); frame.writeUInt16LE(this.nr << 1, 4);
Buffer.from(asdu).copy(frame, 6); this.socket.write(frame);
}
async read() {
for (;;) {
const frame = await this.next(); if (frame[2] === 1) continue;
assert.equal(frame[2] & 1, 0); assert.equal(frame.readUInt16LE(2) >> 1, this.nr++);
const ack = Buffer.from([0x68, 4, 1, 0, 0, 0]); ack.writeUInt16LE(this.nr << 1, 4);
this.socket.write(ack); return frame.subarray(6);
}
}
async receive(type, operation) {
for (let i = 0; i < 100; ++i) {
const a = await this.read();
if (a[0] !== type) { assert([1, 3, 11, 30, 31, 35, 70].includes(a[0])); continue; }
if (operation !== undefined) assert.equal(a[10], operation);
return a;
}
throw new Error('Expected ASDU absent');
}
}
const u32 = n => { const b = Buffer.alloc(4); b.writeUInt32LE(n); return b; };
const named = s => { const b = Buffer.from(s); return Buffer.concat([Buffer.from([b.length]), b]); };
const head = (op, cot) => Buffer.from([210, 1, cot, 0x41, 7, 0, 0, 0, 0, 2, op]);
const cp56 = (day, hour = 0, minute = 0, second = 0) => {
const b = Buffer.from([0, 0, minute, hour, day, 1, 90]); b.writeUInt16LE(second * 1000); return b;
};
async function start() {
const child = spawn(executable, ['--port', '0', '--ca', '7', '--run-ms', '180000',
'--energy-freeze', store, '--energy-period-ms', '2000', '--events', '0',
'--background-ms', '0', '--cyclic-ms', '0', '--no-parameter'],
{ cwd: project, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
let output = '', errors = ''; child.stdout.on('data', b => { output += b; });
child.stderr.on('data', b => { errors += b; }); const exited = once(child, 'exit');
const watchdog = setTimeout(() => child.kill(), 185000); let socket;
try {
let port;
for (let i = 0; i < 1500; ++i) {
const m = output.match(/LISTEN 127\.0\.0\.1:(\d+) CA=7/);
if (m) { port = Number(m[1]); break; }
if (child.exitCode !== null) break;
await delay(10);
}
assert(port, `No listener\n${output}\n${errors}`);
socket = net.connect({ host: '127.0.0.1', port }); const master = new Master(socket);
await once(socket, 'connect'); socket.write(Buffer.from([0x68, 4, 7, 0, 0, 0]));
assert.deepEqual([...(await master.next())], [0x68, 4, 11, 0, 0, 0]);
assert.equal((await master.read())[0], 70);
master.send([100, 1, 6, 0x40, 7, 0, 0, 0, 0, 20]);
for (;;) { const a = await master.read(); if (a[0] === 100 && a[2] === 10) break; }
return { master, async stop() {
socket.destroy(); child.kill(); await exited; clearTimeout(watchdog); assert.equal(errors, '', errors);
} };
} catch (e) {
clearTimeout(watchdog); if (socket) socket.destroy(); child.kill(); await exited;
e.message += `\n${output}\n${errors}`; throw e;
}
}
async function setTime(m, day, hour = 0, minute = 0, second = 0) {
m.send(Buffer.concat([Buffer.from([103, 1, 6, 0x40, 7, 0, 0, 0, 0]), cp56(day, hour, minute, second)]));
assert.equal((await m.receive(103))[2], 7); await delay(30);
}
async function directory(m, name, range) {
const filter = range ? Buffer.concat([Buffer.from([1]), ...range]) : Buffer.alloc(15);
const began = performance.now(); m.send(Buffer.concat([head(1, 5), u32(42), named(name), filter]));
const entries = [];
for (let page = 0; page < 32; ++page) {
const a = await m.receive(210, 2); assert.equal(a[11], 0); assert.equal(a.readUInt32LE(12), 0);
let p = 18;
for (let i = 0; i < a[17]; ++i) {
const n = a[p++], filename = a.subarray(p, p + n).toString(); p += n;
assert.equal(a[p++], 0); const size = a.readUInt32LE(p); p += 4;
const time = Buffer.from(a.subarray(p, p + 7)); p += 7; entries.push({ name: filename, size, time });
}
assert.equal(p, a.length);
if (!a[16]) { console.log(`DIRECTORY ${name} entries=${entries.length} elapsed_ms=${(performance.now() - began).toFixed(1)}`); return entries; }
}
throw new Error('Directory pagination overflow');
}
async function download(m, entry) {
m.send(Buffer.concat([head(3, 6), named(entry.name)])); const a = await m.receive(210, 4);
assert.equal(a[11], 0); const p = 13 + a[12]; assert.equal(a.subarray(13, p).toString(), entry.name);
assert.equal(a.readUInt32LE(p + 4), entry.size); const chunks = []; let offset = 0;
for (let i = 0; i < 3000; ++i) {
const b = await m.receive(210, 5); assert.equal(b.readUInt32LE(15), offset);
const data = b.subarray(20, -1); assert.equal(b.at(-1), data.reduce((x, y) => (x + y) & 255, 0));
chunks.push(data); offset += data.length;
if (!b[19]) {
assert.equal(offset, entry.size);
m.send(Buffer.concat([head(6, 5), u32(0), b.subarray(15, 19), Buffer.from([0])]));
return Buffer.concat(chunks);
}
}
throw new Error('File segment overflow');
}
function parseXml(bytes) {
// The independent .NET XML parser rejects malformed output; no third-party install.
const p = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
'$ErrorActionPreference="Stop"; $x=New-Object System.Xml.XmlDocument; $x.LoadXml([Console]::In.ReadToEnd()); if($x.DocumentElement.Name -ne "DataFile"){exit 1}'],
{ input: bytes, windowsHide: true, encoding: 'utf8' });
assert.equal(p.status, 0, p.stderr);
}
async function counters(m, qcc = 5) {
m.send([101, 1, 6, 0x40, 7, 0, 0, 0, 0, qcc]); const begin = await m.receive(101);
if (qcc !== 5) { assert.equal(begin[2], 0x47); return; }
assert.equal(begin[2], 7); const values = [];
for (;;) {
const a = await m.read();
if (a[0] === 101) { assert.equal(a[2], 10); break; }
assert.equal(a[0], 206); assert.equal(a[2], 37); assert(a[1] & 128);
const ioa = a.readUIntLE(6, 3); assert.equal(ioa, 0x6401 + values.length);
for (let i = 0; i < (a[1] & 127); ++i) {
const value = a.readFloatLE(9 + i * 5); assert(Number.isFinite(value) && value >= 0);
assert.equal(a[13 + i * 5], 0); values.push(value);
}
}
assert.equal(values.length, 8); return values;
}
async function run() {
for (const extra of [['--counter-type', '207'], ['--energy-period-ms', '2001']]) {
const p = spawnSync(executable, ['--energy-freeze', store, ...extra], { windowsHide: true, encoding: 'utf8' });
assert.notEqual(p.status, 0);
}
let first = await start(), frz;
try {
const m = first.master;
for (const qcc of [1, 2, 3, 4, 0x45, 0x85, 0xc5]) await counters(m, qcc);
await counters(m);
for (let slot = 0; slot < 96; ++slot) await setTime(m, 1, Math.floor(slot / 4), (slot % 4) * 15);
assert.equal((await directory(m, 'HISTORY/FRZ')).length, 0);
await setTime(m, 2); await setTime(m, 2, 0, 0, 2);
const entries = await directory(m, 'HISTORY/FRZ'); assert.equal(entries.length, 1);
assert.equal(entries[0].name, 'HISTORY/FRZ/frz20900101.xml');
frz = await download(m, entries[0]); parseXml(frz); const text = frz.toString();
assert(text.includes('sectNum="96"')); assert.equal((text.match(/<DataRec /g) || []).length, 97);
assert.equal((text.match(/<DI val=/g) || []).length, 97 * 8);
assert(text.includes('sect="1" tm="900101_000000"'));
assert(text.includes('sect="96" tm="900101_234500"'));
assert(text.includes('type="DayFrz" tm="900101_000000"'));
for (let ioa = 0x6409; ioa <= 0x6418; ++ioa) assert(text.includes(`ioa="${ioa}"`));
assert.equal((await directory(m, 'HISTORY/FRZ', [cp56(1), cp56(1, 0, 1)])).length, 1);
assert.equal((await directory(m, 'HISTORY/FRZ', [cp56(2), cp56(3)])).length, 0);
await delay(1100);
const flow = await directory(m, 'HISTORY/FLOWREV'); assert.equal(flow.length, 1);
const bytes = await download(m, flow[0]); parseXml(bytes);
const xml = bytes.toString(), num = Number(xml.match(/<DataRec num="(\d+)"/)[1]);
assert(num >= 8 && num % 8 === 0); assert.equal((xml.match(/<DI /g) || []).length, num);
const points = [...xml.matchAll(/<DI ioa="(\d+)" tm="(\d{6}_\d{6}_\d{3})" val="([^"]+)"\/>/g)];
assert.equal(points.length, num);
points.forEach((p, i) => assert.equal(Number(p[1]), 0x6419 + i % 8));
fs.writeFileSync(path.join(store, 'frz.xml'), frz); fs.writeFileSync(path.join(store, 'flowrev.xml'), bytes);
} finally { await first.stop(); }
first = await start();
try {
// Startup wall clock is behind the persisted observation: sealed files still exist.
const entries = await directory(first.master, 'HISTORY/FRZ'); assert.equal(entries.length, 1);
assert.deepEqual(await download(first.master, entries[0]), frz);
await counters(first.master);
await delay(1100);
const flow = await directory(first.master, 'HISTORY/FLOWREV');
parseXml(await download(first.master, flow[0]));
} finally { await first.stop(); }
console.log(`EnergyFreeze TCP, 97 records, FLOWREV, QCC, time filters and forced restart PASS: ${store}`);
}
run().catch(e => { console.error(e); process.exitCode = 1; });