dsh-plc-decode 0.2.1 → 0.2.3

package/assets/dvp-ladder.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/**
+ * dvp-ladder.mjs —— 台达 DVP 文字梯形图（从解码器指令表还原，不自己读字节）
+ *
+ * 数据源唯一：`dvp_decode.py --json` 输出的每条指令（op + args，含 ORB/ANB/MPS/MRD/MPP）。
+ * 报告里解得出什么，图上就画什么：未定名功能码画 `?`/`??` 盒，未识别记录画成触点并在说明里点名，
+ * 不再静默省略。版式与西门子那侧同一个渲染器（lad-branches）。
+ *
+ * CLI：node dvp-ladder.mjs <insts.json> [from] [to]
+ */
+import { readFileSync, writeFileSync, mkdtempSync } from 'node:fs'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const pExecFile = promisify(execFile)
+const ASSETS_DIR = dirname(fileURLToPath(import.meta.url))
+const LAD_BRANCHES = join(ASSETS_DIR, 'lad-branches.mjs')
+
+const CONTACTS = [
+  [/^(LD|AND|OR)$/, (a) => `┤${a}├`],
+  [/^(LDI|ANI|ORI)$/, (a) => `┤/${a}├`],
+  [/^(LDP|ANDP|ORP)$/, (a) => `┤${a}↑├`],
+  [/^(LDF|ANDF|ORF)$/, (a) => `┤${a}↓├`],
+]
+const CONTACT_RE = /^(LD|LDI|LDP|LDF|AND|ANI|ANDP|ANDF|OR|ORI|ORP|ORF)$/
+const CMP_RE = /^(\?)?CMP[（(]([^)）]*)[)）]$/
+
+function contactGlyph(op, args) {
+  const a = args.join(' ')
+  for (const [re, f] of CONTACTS) if (re.test(op)) return f(a)
+  return `┤${op}${a ? ' ' + a : ''}├`
+}
+
+/** 指令流 → 支路行；acc 是「母线到输出」的导线文字，ORB/ANB 按块合并。 */
+function branchRows(insts) {
+  const rows = []
+  const notes = []
+  let acc = ''
+  let hasAcc = false
+  const blocks = []
+  const stack = []
+  const pushAcc = () => { if (hasAcc) { blocks.push(acc); acc = ''; hasAcc = false } }
+  const add = (s) => { acc += s; hasAcc = true }
+
+  // 行首 LD M1000 是母线本身（rail），不再画成第一个触点
+  const list = insts.slice()
+  if (list[0] && list[0].op === 'LD' && (list[0].args ?? [])[0] === 'M1000') list.shift()
+  for (const raw of list) {
+    const op = String(raw.op ?? '')
+    const args = (raw.args ?? []).map(String)
+    if (CONTACT_RE.test(op)) {
+      const g = contactGlyph(op, args)
+      if (op.startsWith('OR')) add('∥' + g)
+      else if (op.startsWith('LD')) { pushAcc(); add(g) }
+      else add(g)
+      continue
+    }
+    const cm = CMP_RE.exec(op)
+    if (cm) {
+      const g = `┤${cm[2] || '?'} ${args.join(' ')}├`
+      if (!hasAcc && rows.length) add(rows[rows.length - 1].wire + '∥' + g)
+      else add(g)
+      continue
+    }
+    if (op.startsWith('〔?') || op.startsWith('?CMP[')) {
+      add(`┤${op}├`)
+      notes.push(`未识别记录 ${op}（报告「未识别记录」一节可对字节）`)
+      continue
+    }
+    if (op === 'MPS') { stack.push(acc); continue }
+    if (op === 'MRD') { acc = stack[stack.length - 1] ?? ''; hasAcc = acc !== ''; continue }
+    if (op === 'MPP') { acc = stack.pop() ?? ''; hasAcc = acc !== ''; continue }
+    if (op === 'ORB') {
+      const b = blocks.pop()
+      if (b !== undefined) { acc = b + '∥' + acc; hasAcc = true }
+      else notes.push('ORB 前没有可合并的上一个块（未还原）')
+      continue
+    }
+    if (op === 'ANB') {
+      const b = blocks.pop()
+      if (b !== undefined) { acc = b + acc; hasAcc = true }
+      else notes.push('ANB 前没有可合并的上一个块（未还原）')
+      continue
+    }
+    // TMR/CTR 这类「带 EN、输出还继续走」的盒：画在导线上，不当终止输出
+    if (op === 'TMR' || op === 'CTR') { add(`[${op} ${args.join(' ')}]`); continue }
+    // 其余一律当输出：OUT / SET / RST / 功能盒；输出不消费条件（同一串条件可带多个线圈）
+    rows.push({ wire: acc, op, args })
+  }
+  if (hasAcc && !rows.length) notes.push(`末尾还剩一段未接输出的条件（${acc}）`)
+  return { rows, notes }
+}
+
+function toSpecRows(rows) {
+  return rows.map((r, i) => {
+    const mark = rows.length === 1 ? '──' : i === 0 ? '┬──' : i === rows.length - 1 ? '└──' : '├──'
+    const wire = mark + r.wire
+    if (/^(SET|RST)$/.test(r.op)) return { wire, coil: `${r.op} ${r.args.join(' ')}` }
+    if (r.op === 'OUT') return { wire, coil: r.args[0] ?? '' }
+    if (r.args.length === 0) return { wire, coil: r.op }
+    return {
+      wire,
+      box: {
+        name: r.op,
+        pins: [
+          { name: 'EN', src: 'cond' },
+          ...r.args.map((a, k) => ({ name: k === r.args.length - 1 ? 'OUT' : `IN${k + 1}`, src: a })),
+        ],
+      },
+    }
+  })
+}
+
+async function renderNet(spec) {
+  const dir = mkdtempSync(join(tmpdir(), 'dvp-lad-'))
+  const f = join(dir, 'n.json')
+  writeFileSync(f, JSON.stringify(spec), 'utf8')
+  const { stdout } = await pExecFile(process.execPath, [LAD_BRANCHES, f], { encoding: 'utf8', maxBuffer: 8 << 20 })
+  return stdout.replace(/\s+$/, '')
+}
+
+/** json：[{ seg, line, insts:[{op,args}] }]；段号按「首条是 LD M1000」的网络编号，与报告网络号一致。 */
+export async function dvpLadder({ json, from, to, title, outFile }) {
+  const data = JSON.parse(readFileSync(json, 'utf8'))
+  const nets = data.filter((r) => {
+    const first = (r.insts ?? [])[0] ?? {}
+    return first.op === 'LD' && (first.args ?? [])[0] === 'M1000'
+  })
+  if (!nets.length) throw new Error('指令表里没有网络（首条 LD M1000）')
+
+  const lo = from ? Number(from) : 1
+  const hi = to ? Number(to) : nets.length
+  const parts = [
+    title ?? '台达 DVP 梯形图（由解码器指令表还原）',
+    '',
+    '说明：段 N＝网络 N（与解码报告的网络号一致，不是报告行号）；图上每个元件都来自解码器指令表，未定名指令画 ?/?? 盒。',
+    '',
+  ]
+  const GROUP = 6
+  for (let k = 0; k < nets.length; k++) {
+    const no = k + 1
+    if (no < lo || no > hi) continue
+    const { rows, notes } = branchRows(nets[k].insts ?? [])
+    if (!rows.length) {
+      parts.push(`段 ${no}（无输出，仅条件）`, '')
+      continue
+    }
+    const specRows = toSpecRows(rows)
+    for (let g = 0; g < specRows.length; g += GROUP) {
+      const grp = specRows.slice(g, g + GROUP)
+      const spec = {
+        title: specRows.length > GROUP ? `段 ${no}（${g + 1}-${g + grp.length}/${specRows.length} 支）` : `段 ${no}`,
+        rail: 'M1000',
+        rows: grp,
+        comments: notes,
+      }
+      parts.push(await renderNet(spec), '')
+    }
+  }
+  const out = parts.join('\n')
+  if (outFile) writeFileSync(outFile, out, 'utf8')
+  return out
+}
+
+/* CLI */
+if (process.argv[1] && process.argv[1].endsWith('dvp-ladder.mjs')) {
+  const [json, from, to] = process.argv.slice(2)
+  dvpLadder({ json, from, to })
+    .then((t) => process.stdout.write(t))
+    .catch((e) => { console.error(String(e)); process.exit(1) })
+}

package/assets/ebpro-decode.mjs

@@ -0,0 +1,305 @@
+// ebpro-decode.mjs —— 威纶通 EasyBuilder Pro 工程解码（.emtp / 编译产物 .exob）
+//
+// 格式：.emtp 工程本体是「头 + 一大块压缩/加密数据」，读不出结构；同工程「编译」(F7)
+// 生成的 .exob 是 UTF-8 明文，里面能读的有三段：
+//   LABE_LIB          文字库：逐条 [1B 名长][1B 状态1长][1B 状态2长] + 三段 UTF-8（只有源语言）
+//   画面对象记录       'HA' + 2 字节类型码 + 若干记录；记录 = 21 字节头（+0..+7 文字度量 u16，
+//                     +12 语言槽 id，+14..+17 文本字节数 u32）+ UTF-8 文本 + 0x00
+//   其余段（TAG_DATA / MACRO_ID …）内容未定，本解码器不解析、不猜。
+//
+// 用法：node ebpro-decode.mjs <工程.emtp | 编译产物.exob | 工程目录> [输出目录] [--exob 路径]
+// 输出（默认 <cwd>/解码归档/<工程名>/HMI解码/）：
+//   00-格式说明.md      来源、结构、判定口径、能解与不能解
+//   10-画面.tsv         画面名(推定) / 编号(画面标题对象偏移) / 文字对象数
+//   11-文字对象.tsv     所属画面(推定) / 类型码 / 语言槽 / 文字 / 度量 x y w h / 对象偏移
+//   12-报警事件.tsv     对象偏移 / 语言槽 / 文本
+//   13-文字库.tsv       条目名 / 状态1 / 状态2
+//   HMI解码报告.md      概述 + 画面清单 + 语言槽分布 + 边界
+//   08-统计.json        同一批数据的结构化版
+// 只读：不修改工程与编译产物。
+import fs from 'node:fs'
+import path from 'node:path'
+
+const TYPES = new Set([0x1410, 0x1408, 0x0402, 0x0401])
+const CTRL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f]/
+const CJK = /[\u4e00-\u9fff]/
+const LATIN = /[A-Za-z]{2,}/
+
+const argv = process.argv.slice(2)
+const flags = { exob: '' }
+const pos = []
+for (let i = 0; i < argv.length; i++) {
+  if (argv[i] === '--exob') flags.exob = argv[++i] || ''
+  else pos.push(argv[i])
+}
+if (!pos[0]) {
+  console.error('用法: node ebpro-decode.mjs <工程.emtp | 编译产物.exob | 工程目录> [输出目录] [--exob 路径]')
+  process.exit(2)
+}
+
+function fail(msg) { console.error(msg); process.exit(3) }
+
+/** 输入 → { exob, emtp }：.emtp/.目录 自动找同目录同名 .exob */
+function resolveInputs(arg, exobArg) {
+  const abs = path.resolve(arg)
+  if (!fs.existsSync(abs)) fail(`路径不存在: ${arg}`)
+  if (fs.statSync(abs).isDirectory()) {
+    const files = fs.readdirSync(abs)
+    const exobs = files.filter((f) => f.toLowerCase().endsWith('.exob'))
+      .map((f) => path.join(abs, f)).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)
+    const emtps = files.filter((f) => f.toLowerCase().endsWith('.emtp'))
+      .map((f) => path.join(abs, f)).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)
+    if (!exobs.length) fail(`目录里没有 .exob 编译产物：${abs}\n先在 EasyBuilder Pro 里编译（F7）再跑。`)
+    return { exob: exobArg ? path.resolve(exobArg) : exobs[0], emtp: emtps[0] || '' }
+  }
+  const low = abs.toLowerCase()
+  if (low.endsWith('.emtp')) {
+    if (exobArg) return { exob: path.resolve(exobArg), emtp: abs }
+    const sib = abs.replace(/\.emtp$/i, '.exob')
+    if (!fs.existsSync(sib)) fail(`找不到同名编译产物：${sib}\n.emtp 本体压缩+加密，读不动；在 EasyBuilder Pro 里编译（F7）生成 .exob 后再跑。`)
+    return { exob: sib, emtp: abs }
+  }
+  if (low.endsWith('.exob')) {
+    const sib = abs.replace(/\.exob$/i, '.emtp')
+    return { exob: abs, emtp: fs.existsSync(sib) ? sib : '' }
+  }
+  fail(`不认的输入：${arg}（要 .emtp 工程、.exob 编译产物或工程目录）`)
+}
+
+/** 工程本体头部：FF FE FF + 1 字节长 + UTF-16LE 的版本串（其余压缩+加密） */
+function emtpMeta(p) {
+  if (!p || !fs.existsSync(p)) return null
+  const d = fs.readFileSync(p).subarray(0, 64)
+  const i = d.indexOf(Buffer.from([0xff, 0xfe, 0xff]))
+  const meta = { path: p, size: fs.statSync(p).size, mtime: fs.statSync(p).mtime }
+  if (i >= 0 && i + 4 <= d.length) {
+    const len = d[i + 3]
+    meta.version = d.subarray(i + 4, i + 4 + len * 2).toString('utf16le')
+  }
+  return meta
+}
+
+/** LABE_LIB：条目名 + 状态1 + 状态2（只有源语言，没有译文） */
+function parseLib(buf) {
+  const at = buf.indexOf(Buffer.from('LABE_LIB'))
+  if (at < 0) return []
+  let p = at + 8 + 2
+  const out = []
+  while (p + 3 < buf.length) {
+    const nl = buf[p], t1 = buf[p + 1], t2 = buf[p + 2]
+    if (nl === 0 || nl > 100 || t1 > 200 || t2 > 200) break
+    const q = p + 3
+    if (q + nl + t1 + t2 > buf.length) break
+    const name = buf.subarray(q, q + nl).toString('utf8')
+    const s1 = buf.subarray(q + nl, q + nl + t1).toString('utf8')
+    const s2 = buf.subarray(q + nl + t1, q + nl + t1 + t2).toString('utf8')
+    out.push({ name, s1, s2 })
+    p = q + nl + t1 + t2
+  }
+  return out
+}
+
+/** 记录流：21 字节头 + 文本 + 0x00 */
+function parseRecords(buf, start, limit) {
+  let p = start
+  const out = []
+  while (p + 21 <= limit) {
+    const x = buf.readUInt16LE(p)
+    const y = buf.readUInt16LE(p + 2)
+    const w = buf.readUInt16LE(p + 4)
+    const h = buf.readUInt16LE(p + 6)
+    const lang = buf[p + 12]
+    const len = buf.readUInt32LE(p + 14)
+    const tsp = p + 21
+    if (len === 0) { out.push({ x, y, w, h, lang, text: '', at: tsp }); p = tsp; continue }
+    if (len > 400 || tsp + len >= limit) break
+    const text = buf.subarray(tsp, tsp + len).toString('utf8')
+    if (buf[tsp + len] !== 0) break
+    out.push({ x, y, w, h, lang, text, at: tsp })
+    p = tsp + len + 1
+  }
+  return { recs: out, next: p }
+}
+
+/** 对象：'HA' + 2 字节类型码 + 记录 */
+function parseObjects(buf) {
+  const out = []
+  let p = 0
+  while (true) {
+    const j = buf.indexOf(Buffer.from('HA'), p)
+    if (j < 0 || j + 4 > buf.length) break
+    const ty = (buf[j + 2] << 8) | buf[j + 3]
+    if (!TYPES.has(ty)) { p = j + 1; continue }
+    const { recs, next } = parseRecords(buf, j + 5, Math.min(j + 6000, buf.length))
+    if (recs.length) { out.push({ off: j, type: ty, recs }); p = next } else p = j + 1
+  }
+  return out
+}
+
+/** 能当文字用的记录：有字、无控制字符、语言槽 0..23（文件里夹着另一种 24 字节结构，会解出 NUL 串） */
+const usable = (r) => {
+  const t = r.text.trim()
+  return t !== '' && !CTRL.test(t) && r.lang >= 0 && r.lang <= 23
+}
+
+const fmtTime = (d) => {
+  const p = (n) => String(n).padStart(2, '0')
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`
+}
+
+function main() {
+  const { exob, emtp } = resolveInputs(pos[0], flags.exob)
+  const outDir = path.resolve(pos[1] || path.join(process.cwd(), '解码归档', path.basename(emtp || exob, path.extname(emtp || exob)), 'HMI解码'))
+  fs.mkdirSync(outDir, { recursive: true })
+
+  const buf = fs.readFileSync(exob)
+  const lib = parseLib(buf)
+  const objs = parseObjects(buf)
+  if (!objs.length) fail(`没解析到画面对象：${exob}\n可能这份 .exob 不是 EasyBuilder Pro 编出来的。`)
+
+  // 语言槽：源语言＝含中文最多的槽（并列取小），目标语言＝拉丁字母最多的槽
+  const cjk = new Map(), latin = new Map()
+  for (const o of objs) {
+    for (const r of o.recs) {
+      if (!usable(r)) continue
+      if (CJK.test(r.text)) cjk.set(r.lang, (cjk.get(r.lang) || 0) + 1)
+      else if (LATIN.test(r.text)) latin.set(r.lang, (latin.get(r.lang) || 0) + 1)
+    }
+  }
+  const pick = (m, dflt) => [...m.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0]?.[0] ?? dflt
+  const zhLang = pick(cjk, null)
+  const enLang = pick(latin, null)
+
+  // 画面：大号标签对象（0x1408 且度量 ≥ 150×35）
+  const screens = objs.filter((o) => o.type === 0x1408
+    && o.recs.some((r) => usable(r) && r.w >= 150 && r.h >= 35))
+    .sort((a, b) => a.off - b.off)
+    .map((o) => {
+      let name = ''
+      for (const r of o.recs) if (usable(r) && r.lang === zhLang) { name = r.text.trim(); break }
+      if (!name) for (const r of o.recs) if (usable(r)) { name = r.text.trim(); break }
+      return { off: o.off, name: name || '（无标题文字）' }
+    })
+
+  const screenOf = (off) => {
+    let name = '（首屏之前）'
+    for (const s of screens) if (off >= s.off) name = s.name
+    return name
+  }
+
+  // 文字对象：同一对象内「同语言同文字」重复的只留一条
+  const words = []
+  for (const o of objs) {
+    const seen = new Set()
+    const recs = []
+    for (const r of o.recs) {
+      if (!usable(r)) continue
+      const key = JSON.stringify([r.lang, r.text.trim()])
+      if (seen.has(key)) continue
+      seen.add(key)
+      recs.push(r)
+    }
+    if (recs.length) words.push({ off: o.off, type: o.type, screen: screenOf(o.off), recs })
+  }
+  const events = words.filter((w) => w.type === 0x0401)
+  const screenWords = words.filter((w) => w.type !== 0x0401)
+
+  const langDist = {}
+  for (const w of words) for (const r of w.recs) langDist[r.lang] = (langDist[r.lang] || 0) + 1
+
+  const stat = {
+    source: {
+      exob: { path: exob, size: buf.length, mtime: fmtTime(fs.statSync(exob).mtime) },
+      emtp: emtp ? { path: emtp, size: fs.statSync(emtp).size, mtime: fmtTime(fs.statSync(emtp).mtime), version: emtpMeta(emtp)?.version } : null,
+    },
+    languages: { source: zhLang, target: enLang, distribution: langDist },
+    counts: { screens: screens.length, screenTextObjects: screenWords.length, events: events.length, library: lib.length },
+    screens,
+    objects: words,
+    library: lib,
+  }
+
+  const w = (name, content) => fs.writeFileSync(path.join(outDir, name), content, 'utf8')
+  const tsv = (head, rows) => head + '\n' + rows.map((r) => r.join('\t')).join('\n') + '\n'
+
+  w('10-画面.tsv', tsv('画面名(推定)\t编号(标题对象偏移)\t文字对象数',
+    screens.map((s) => [s.name, '0x' + s.off.toString(16).toUpperCase(), screenWords.filter((x) => x.screen === s.name).length])))
+
+  w('11-文字对象.tsv', tsv('所属画面(推定)\t类型码\t语言槽\t文字\t度量x\t度量y\t宽\t高\t对象偏移',
+    screenWords.flatMap((x) => x.recs.map((r) => [x.screen, '0x' + x.type.toString(16).toUpperCase().padStart(4, '0'),
+      r.lang, r.text.trim().replace(/\t/g, ' '), r.x, r.y, r.w, r.h, '0x' + x.off.toString(16).toUpperCase()]))))
+
+  w('12-报警事件.tsv', tsv('对象偏移\t语言槽\t文本',
+    events.flatMap((x) => x.recs.map((r) => ['0x' + x.off.toString(16).toUpperCase(), r.lang, r.text.trim().replace(/\t/g, ' ')]))))
+
+  w('13-文字库.tsv', tsv('条目名\t状态1\t状态2',
+    lib.map((e) => [e.name, e.s1.trim(), e.s2.trim()])))
+
+  const stale = emtp && fs.statSync(emtp).mtimeMs > fs.statSync(exob).mtimeMs + 60000
+
+  w('00-格式说明.md', [
+    '# 威纶通 EasyBuilder Pro（.emtp / .exob）格式说明',
+    '',
+    '| 文件 | 是什么 | 能不能读 |',
+    '|---|---|---|',
+    '| `.emtp` | 工程本体 | 头 4 字节后有 `FF FE FF + 1 字节长 + UTF-16LE` 的工程版本串；其后是压缩+加密数据，读不出结构 |',
+    '| `.exob` | 编译产物（软件里编译一次，与工程同名同目录） | UTF-8 明文：文字库段 `LABE_LIB` + 画面对象记录 + 若干未定段 |',
+    '',
+    '## 结构（本解码器用到的那两段）',
+    '',
+    '- `LABE_LIB`：标记后跳 2 字节，逐条 `[1B 名长][1B 状态1长][1B 状态2长]` + 三段 UTF-8。这一段**只有源语言**，没有译文。',
+    '- 对象记录：`HA` + 2 字节类型码 + 若干记录；记录 = 21 字节头（`+0..+7` 文字度量 u16 x/y/w/h，`+12` 语言槽 id，`+14..+17` 文本字节数 u32）+ UTF-8 文本 + `0x00`。',
+    '- 类型码原值：`0x1408` / `0x1410` / `0x0402` / `0x0401`；含义未判死，表里只用码不写类别名。',
+    '',
+    '## 判定口径',
+    '',
+    '- 语言槽：源语言＝含中文最多的槽（并列取小）；目标语言＝拉丁字母最多的槽。',
+    '- 画面：以「度量 ≥ 150×35 的 0x1408 标签对象」当画面标题，其后的对象归这个画面；没有标题对象的画面会并到上一个。',
+    '- 噪声过滤：文本含控制字符、或语言槽 id 不在 0..23 的记录不是文字（文件里夹着另一种 24 字节结构，按本格式会解出 NUL 串）。',
+    '',
+    '## 能解与不能解',
+    '',
+    '- 能解：画面名（推定）、文字对象（所属画面/类型码/语言槽/文字/度量/偏移）、报警事件文本、文字库条目、工程版本。',
+    '- 不能解：工程本体 `.emtp`（压缩+加密）；控件几何与画面坐标；PLC 地址与变量绑定（编译产物里没有可读的标签表段）。',
+    '- 度量列 x/y/w/h 是字串外框度量，不是画面坐标。',
+    '',
+  ].join('\n'))
+
+  const L = []
+  L.push(`# ${path.basename(emtp || exob, path.extname(emtp || exob))} · EasyBuilder Pro HMI 解码报告`)
+  L.push('')
+  L.push(`- 编译产物: ${path.basename(exob)}（${fmtTime(fs.statSync(exob).mtime)}，${(buf.length / 1048576).toFixed(2)} MB，UTF-8 明文段）`)
+  L.push(emtp ? `- 工程文件: ${path.basename(emtp)}（${(fs.statSync(emtp).size / 1048576).toFixed(2)} MB，工程版本 ${emtpMeta(emtp)?.version || '未知'}；本体压缩+加密）` : '- 工程文件: （未提供，只给了编译产物）')
+  L.push(`- 规模: 画面 ${screens.length}（推定）/ 文字对象 ${screenWords.length} / 报警事件 ${events.length} / 文字库 ${lib.length} 条`)
+  L.push(`- 语言槽: 源 ${zhLang ?? '未识别'} / 目标 ${enLang ?? '未识别'}；分布 ${Object.entries(langDist).sort((a, b) => a[0] - b[0]).map(([k, v]) => `${k} 槽 ${v} 条`).join('，')}`)
+  if (stale) L.push(`- 注意: 工程比编译产物新，表是上一次编译的状态；要最新就在软件里重新编译再跑`)
+  L.push('')
+  L.push('## 画面清单')
+  L.push('')
+  L.push('| 画面名(推定) | 文字对象数 | 标题对象偏移 |')
+  L.push('|---|---|---|')
+  for (const s of screens) L.push(`| ${s.name.replace(/\|/g, '/')} | ${screenWords.filter((x) => x.screen === s.name).length} | 0x${s.off.toString(16).toUpperCase()} |`)
+  L.push('')
+  L.push('## 报警事件（前 40）')
+  L.push('')
+  L.push('| 语言槽 | 文本 |')
+  L.push('|---|---|')
+  for (const x of events.slice(0, 40)) for (const r of x.recs) L.push(`| ${r.lang} | ${r.text.trim().replace(/\|/g, '/')} |`)
+  L.push('')
+  L.push('## 文字库（前 40）')
+  L.push('')
+  L.push('| 条目名 | 状态1 | 状态2 |')
+  L.push('|---|---|---|')
+  for (const e of lib.slice(0, 40)) L.push(`| ${e.name.replace(/\|/g, '/')} | ${e.s1.trim().replace(/\|/g, '/')} | ${e.s2.trim().replace(/\|/g, '/')} |`)
+  L.push('')
+  L.push('先读这份；原始表在 10-画面.tsv / 11-文字对象.tsv / 12-报警事件.tsv / 13-文字库.tsv，结构化数据在 08-统计.json。')
+  w('HMI解码报告.md', L.join('\n') + '\n')
+  w('08-统计.json', JSON.stringify(stat, null, 1))
+
+  console.log(`OK ${path.basename(emtp || exob)} → ${outDir}`)
+  console.log(`   画面 ${screens.length}（推定）/ 文字对象 ${screenWords.length} / 报警事件 ${events.length} / 文字库 ${lib.length} 条`)
+  console.log(`   语言槽: 源 ${zhLang ?? '?'} / 目标 ${enLang ?? '?'}`)
+  if (stale) console.log('   注意: 工程比编译产物新，表是上一次编译的状态')
+}
+
+main()

package/assets/hmi-decode-workflow.md

@@ -7,9 +7,8 @@
 | 文件 | 是什么 | 用哪个 |
 |---|---|---|
 | `.hmismart` | 西门子 WinCC flexible SMART 触摸屏工程（Smart Line 屏） | 工具 `hmi-decode`（解码）／`hmi-diff-project`（新旧对比） |
-| `.fsprj` 或含 `HMI\Frame` 的目录 | 繁易 FStudio / Flexem 触摸屏工程 | 工具 `hmi-decode`（扫文本）／`fstudio-scan-texts`／`fstudio-i18n`（多语言出表） |
-| `<工程名>.设备_1.srt`（同目录） | 项目文本侧的序列化存储 | 主文件被锁时的旁路，见第三节 |
-| `Screens.xls` / `Others.xls` / `Messages.xls` | WinCC flexible「项目文本」导出成的 Excel 三件套 | 工具 `wincc-text-i18n`（分型／回写／自检），流程见技能 `wincc-text-i18n-workflow` |
+| `.fsprj` 或含 `HMI\Frame` 的目录 | 繁易 FStudio / Flexem 触摸屏工程 | 工具 `hmi-decode`（画面 / 控件 / 地址表 + 元件文本扫描） |
+| `<工程名>.srt`（同目录） | 项目文本侧的序列化存储 | 主文件被锁时的旁路，见第三节 |
 
 **第一原则与 PLC 侧相同：先要"软件里能导出的东西"**。触摸屏这边对应的是：画面清单/变量表（软件里能导 CSV 或看变量表）——导出来对账，比在工程里挖快一个数量级。
 
@@ -30,9 +29,9 @@
 `.hmismart` 被 WinCC 打开时是**独占锁**（连 `FileShare.ReadWrite` 都打不开）。这时不必关软件，同目录的 `{{GUID}}.data` 就是工程数据的旁路：
 
 - 结构：`ES2RT` 头（前 10 字节）+ gzip 流（`1F 8B 08` 起），解出来是 .NET 序列化对象图（20MB 量级），**UTF-8，字符串可读**。
-- 你能直接从中拿到：**变量表全部标签名**（含 `文件夹_N\MW5212` 这类「以地址命名」的标签与中文命名标签）、**连接与驱动名**（如 `driver.Modicon MODBUS Standard V3`）、画面/控件文本。
+- 你能直接从中拿到：**变量表全部标签名**（含以地址命名的标签与中文命名标签）、**连接与驱动名**、画面/控件文本。
 - 拿不到：**变量的 Modbus 地址号**（二进制存，工程里没有明文字样）——读不到就直说读不到，别编；判定靠现场按一下看对应位是否变，或让用户从变量表导一份出来。
-- 用法：按具体串搜（`MW5212`、`驱动名`、中文标签名），避开宽 pattern。
+- 用法：按具体串搜（具体地址串、驱动名、中文标签名），避开宽 pattern。
 
 ## 三、`.srt` 项目文本（主文件锁着时的另一条旁路）
 
@@ -41,13 +40,12 @@
 - **陷阱**：① 中文不要用 GBK 解（UTF-16 才对齐）；② 抽「中文→英文」对时跳过元素引用/变量地址/空串；③ 截图「项目文本」页可与 `.srt` 内容逐条吻合，能当真值校准。
 - **旁系文件**：`*.transfer`（UTF-16 XML，含设备型号/页面清单）、`*.data`（见上）、`*.chk/.cnk/.rdf/.pwx`（校验/密码，跳过）。
 
-## 四、繁易 FStudio（多语言另见专篇）
+## 四、繁易 FStudio
 
-- 工具：`hmi-decode`（读工程→扫元件文本）、`fstudio-scan-texts`（只看要翻什么）、`fstudio-i18n`（出对照表 + 可导入文本库的表）。
-- 方法与踩坑见同插件技能 **`fstudio-i18n-workflow`**：列名逐字符一致、元件文字常写死不走文本库、原工程英文槽常是错填。
+- 工具：`hmi-decode`（读工程 → 画面 / 控件 / 控件地址表，并扫元件文本）。
 
 ## 五、交付与边界
 
 - 产物约定：`.hmismart` 写 `<工作区>\解码归档\<工程名>\HMI解码\`；FStudio 写 `<工程目录>\多语言产出\`。**不写系统临时目录、不污染工程目录**。
 - 只读源工程；`解码归档` 里的报告是某个版本的快照，拿旧报告对账前先比源文件的**大小 + 修改时间**。
-- 屏上地址为什么长成"不是西门子那种格式"（M 区名、Modbus 号、命名习惯）：见 PLC 侧技能 `codesys-teach-workflow` §5——那是工程地址面的事，不在这里重复。
+- 屏上地址不是西门子那种格式时（M 区名、Modbus 号、命名习惯）：先解同机 PLC 工程（`plc-decode`），看 M 区 IO 映射与参数表，再回来看屏地址。