feat: 重构 AGV 对接与在制品查询,新增 PLC 手动监控功能

This commit is contained in:
SunYF
2026-10-17 17:49:47 +08:00
parent f65a52d9e1
commit f743cf21fb
96 changed files with 6130 additions and 1781 deletions
+65 -1
View File
@@ -3,6 +3,7 @@ package plc
import (
"context"
"errors"
"fmt"
"sync"
)
@@ -16,10 +17,30 @@ type mockClient struct {
// stationPallet 模拟工位托盘位是否有件(PLC↔MES 对账用):key=工位号,默认全部无件;
// 联调/自测时可用 SetStationPallet 置位,模拟“PLC 说有位、MES 说无工件”的 mismatch 场景。
stationPallet map[int]bool
// bits 模拟 48 位点位信号(§4.1):[0..11]G1..G12 [12..26]C1..C15 [27..46]DOCK01..DOCK20 [47]JBT21
bits []bool
// mw 模拟 MW 寄存器当前值(§4.4 覆盖的 MW800..MW886)
mw map[int]int
// mBytes 模拟任意 Merker 字节(强制写 M 位用):key=字节偏移,默认全 0
mBytes map[int]byte
}
func newMockClient() *mockClient {
return &mockClient{dockPallet: map[string]bool{}, stationPallet: map[int]bool{}}
m := &mockClient{
dockPallet: map[string]bool{},
stationPallet: map[int]bool{},
bits: make([]bool, 48),
mw: map[int]int{},
mBytes: map[int]byte{},
}
// 预置若干点位为“有托盘”,便于手动监控页 mock 演示 48 位状态展示(●/○ 混合)
for _, i := range []int{0, 1, 12, 13, 14, 27, 28, 29, 47} {
m.bits[i] = true
}
// 预置两条在途指令(MW 非0),便于演示 2.2 动作类信号解析(非0即解析 源→目标)
m.mw[800] = 105 // MW800 = 105 → G1 → C5(A 类)
m.mw[872] = 305 // MW872 = 305 → C3 → C5(D 类)
return m
}
// SetDockPallet 手动设置某接驳台是否有托盘(供联调/测试用)
@@ -66,4 +87,47 @@ func (m *mockClient) QueryStationPallet(_ context.Context, stationNo int) (bool,
m.mu.RLock()
defer m.mu.RUnlock()
return m.stationPallet[stationNo], nil
}
// ReadBits 读 48 位点位信号(mock):返回内存态位数组。
func (m *mockClient) ReadBits(_ context.Context) ([]bool, error) {
m.mu.RLock()
defer m.mu.RUnlock()
out := make([]bool, len(m.bits))
copy(out, m.bits)
return out, nil
}
// ReadMW 读 16 位寄存器(mock):返回内存态 MW 值,缺省 0。
func (m *mockClient) ReadMW(_ context.Context, addr int) (int, error) {
m.mu.RLock()
defer m.mu.RUnlock()
return m.mw[addr], nil
}
// WriteMW 写 16 位寄存器(mock):写入内存态 MW,供手动下发演示。
func (m *mockClient) WriteMW(_ context.Context, addr, value int) error {
m.mu.Lock()
defer m.mu.Unlock()
m.mw[addr] = value
return nil
}
// WriteBit 强制写单个 M 位(mock):读写内存态 mBytes,返回写前/写后值。
func (m *mockClient) WriteBit(_ context.Context, merkerByte, merkerBit int, on bool) (before, after bool, err error) {
if merkerByte < 0 || merkerBit < 0 || merkerBit > 7 {
return false, false, fmt.Errorf("非法的 M 位:MB%d.%d", merkerByte, merkerBit)
}
m.mu.Lock()
defer m.mu.Unlock()
cur := m.mBytes[merkerByte]
before = cur&(1<<merkerBit) != 0
if on {
cur |= 1 << merkerBit
} else {
cur &^= 1 << merkerBit
}
m.mBytes[merkerByte] = cur
after = cur&(1<<merkerBit) != 0
return before, after, nil
}
+36
View File
@@ -28,6 +28,21 @@ type Client interface {
// 暂未接真实 PLC 时 mock 按置位返回(默认无件);真实 S7 对接(G1~G10→M895.0~M896.1、C15→M898.2)
// 后由 tcp 实现补读寄存器逻辑。
QueryStationPallet(ctx context.Context, stationNo int) (bool, error)
// ReadBits 读取 48 位点位信号(产线布局说明.md §4.1),返回顺序固定:
// [0..11] G1..G12 工位托盘位
// [12..26] C1..C15 主线缓存位
// [27..46] DOCK01..DOCK20 工位接驳台托盘位
// [47] JBT21 库房接驳台
// 用于 PLC 手动监控页(一次性读取,不轮询)。
ReadBits(ctx context.Context) ([]bool, error)
// ReadMW 读取 16 位寄存器(MW)当前值(大端)。用于监控页读 MW800~MW886。
ReadMW(ctx context.Context, addr int) (int, error)
// WriteMW 向 16 位寄存器(MW)写入值(大端)。用于手动下发路径指令。
WriteMW(ctx context.Context, addr, value int) error
// WriteBit 对单个 Merker 位(MB merkerByte 的 merkerBit 位)强制置/复位(on=true 置 1)。
// 返回写入前的位值 before 与写后即时回读的位值 after(M 位可能被 PLC 程序循环覆盖,after 仅反映即时态)。
// 仅用于停机/调试。
WriteBit(ctx context.Context, merkerByte, merkerBit int, on bool) (before, after bool, err error)
}
// Manager 管理 PLC 客户端实例
@@ -68,6 +83,27 @@ func (m *Manager) QueryStationPallet(ctx context.Context, stationNo int) (bool,
return v, err
}
// ReadBits 读 48 位点位信号(带恢复检测)。
func (m *Manager) ReadBits(ctx context.Context) ([]bool, error) {
v, err := m.client.ReadBits(ctx)
m.track(err)
return v, err
}
// ReadMW 读 16 位寄存器(带恢复检测)。
func (m *Manager) ReadMW(ctx context.Context, addr int) (int, error) {
v, err := m.client.ReadMW(ctx, addr)
m.track(err)
return v, err
}
// WriteMW 写 16 位寄存器(带恢复检测)。
func (m *Manager) WriteMW(ctx context.Context, addr, value int) error {
err := m.client.WriteMW(ctx, addr, value)
m.track(err)
return err
}
// track 失败计数:连续失败后首次成功沿触发一次 OnRecover(避免阻塞查询调用方,异步触发)。
func (m *Manager) track(err error) {
m.mu.Lock()
+299
View File
@@ -0,0 +1,299 @@
package plc
// 路由表(产线布局说明.md §4.4,硬编码为唯一真源,前端不复制)。
// 值 = 源编号 × 100 + 目标编号;MW 地址按 (类, 源) 确定。
// 四类:
//
// A 工位→主线 (G→C)
// B 工位→工位 (G→G)
// C 主线→工位 (C→G)
// D 主线→主线 (C→C)
//
// 目标集合严格按 §4.4 列出(B 类高位工位有缺口,如 G10→{9,11,12})。
// 与 §4.1 位地址、§4.2 数值编码规则一致。
import (
"sort"
"strconv"
)
// RouteCategory 路由类别
type RouteCategory string
const (
CatA RouteCategory = "A" // 工位→主线 G→C
CatB RouteCategory = "B" // 工位→工位 G→G
CatC RouteCategory = "C" // 主线→工位 C→G
CatD RouteCategory = "D" // 主线→主线 C→C
)
// SrcType 源/目标类型
type SrcType string
const (
SrcStation SrcType = "G" // 工位
SrcMain SrcType = "C" // 主线
)
// mwRoute 一条路由记录:某类、某源、对应 MW 地址、允许的目标编号集合。
type mwRoute struct {
Cat RouteCategory
Src int // 源编号(G 或 C 编号,1 起)
MW int // MW 地址
Tgts []int
}
// seq 生成 [a..b] 连续整数(含端点),便于紧凑表达 §4.4 的连续目标区间。
func seq(a, b int) []int {
if b < a {
return nil
}
out := make([]int, 0, b-a+1)
for i := a; i <= b; i++ {
out = append(out, i)
}
return out
}
// mwRoutes 全部 §4.4 路由记录(45 条 MW)。
var mwRoutes = []mwRoute{
// ===== A 工位→主线 (G→C) =====
{CatA, 1, 800, seq(1, 15)},
{CatA, 2, 802, seq(1, 15)},
{CatA, 3, 804, seq(4, 15)},
{CatA, 4, 806, seq(4, 15)},
{CatA, 5, 808, seq(7, 15)},
{CatA, 6, 810, seq(7, 15)},
{CatA, 7, 812, seq(10, 15)},
{CatA, 8, 814, seq(10, 15)},
{CatA, 9, 816, seq(13, 15)},
{CatA, 10, 818, seq(13, 15)},
{CatA, 11, 820, []int{15}},
{CatA, 12, 822, []int{15}},
// ===== B 工位→工位 (G→G) =====
{CatB, 1, 824, seq(2, 12)},
{CatB, 2, 826, append([]int{1}, seq(3, 12)...)}, // G2→G1, G3..G12
{CatB, 3, 828, seq(4, 12)}, // G3→G4..G12
{CatB, 4, 830, append([]int{3}, seq(5, 12)...)}, // G4→G3, G5..G12
{CatB, 5, 832, seq(6, 12)}, // G5→G6..G12
{CatB, 6, 834, append([]int{5}, seq(7, 12)...)}, // G6→G5, G7..G12
{CatB, 7, 836, seq(8, 12)}, // G7→G8..G12
{CatB, 8, 838, append([]int{7}, seq(9, 12)...)}, // G8→G7, G9..G12
{CatB, 9, 840, seq(10, 12)}, // G9→G10..G12
{CatB, 10, 842, []int{9, 11, 12}}, // G10→G9, G11, G12
{CatB, 11, 844, []int{12}}, // G11→G12
{CatB, 12, 844, []int{11}}, // G12→G11
// ===== C 主线→工位 (C→G) =====
{CatC, 1, 846, seq(1, 12)},
{CatC, 2, 848, seq(3, 12)},
{CatC, 3, 850, seq(3, 12)},
{CatC, 5, 852, seq(5, 12)},
{CatC, 6, 854, seq(5, 12)},
{CatC, 8, 856, seq(7, 12)},
{CatC, 9, 858, seq(7, 12)},
{CatC, 11, 860, seq(9, 12)},
{CatC, 12, 862, seq(9, 12)},
{CatC, 14, 864, []int{11, 12}},
{CatC, 15, 866, []int{11, 12}},
// ===== D 主线→主线 (C→C) =====
{CatD, 1, 868, seq(2, 15)},
{CatD, 2, 870, seq(3, 15)},
{CatD, 3, 872, seq(4, 15)},
{CatD, 5, 874, seq(6, 15)},
{CatD, 6, 876, seq(7, 15)},
{CatD, 8, 878, seq(9, 15)},
{CatD, 9, 880, seq(10, 15)},
{CatD, 11, 882, seq(12, 15)},
{CatD, 12, 884, seq(13, 15)},
{CatD, 14, 886, []int{15}},
}
// categoryOf 由源/目标类型推断路由类别
func categoryOf(srcType, tgtType SrcType) (RouteCategory, bool) {
if srcType == SrcStation && tgtType == SrcMain {
return CatA, true
}
if srcType == SrcStation && tgtType == SrcStation {
return CatB, true
}
if srcType == SrcMain && tgtType == SrcStation {
return CatC, true
}
if srcType == SrcMain && tgtType == SrcMain {
return CatD, true
}
return "", false
}
// LookupRoute 校验 (srcType,src,tgtType,tgt) 是否合法,返回 MW 地址与写入值。
// 值 = 源 × 100 + 目标(§4.2)。非法组合返回 ok=false。
func LookupRoute(srcType SrcType, src, tgt int, tgtType SrcType) (mw, value int, ok bool) {
cat, cok := categoryOf(srcType, tgtType)
if !cok || src < 1 || tgt < 1 {
return 0, 0, false
}
for _, r := range mwRoutes {
if r.Cat != cat || r.Src != src {
continue
}
for _, t := range r.Tgts {
if t == tgt {
return r.MW, src*100 + tgt, true
}
}
}
return 0, 0, false
}
// AllTargets 返回某源允许的合法目标编号(用于前端下拉动态过滤)。
func AllTargets(srcType SrcType, src int, tgtType SrcType) []int {
cat, ok := categoryOf(srcType, tgtType)
if !ok {
return nil
}
for _, r := range mwRoutes {
if r.Cat == cat && r.Src == src {
out := make([]int, len(r.Tgts))
copy(out, r.Tgts)
sort.Ints(out)
return out
}
}
return nil
}
// MWCategory 由 MW 地址反查所属路由类别(用于解析 MW 当前值的源/目标类型)。
func MWCategory(addr int) (RouteCategory, bool) {
for _, r := range mwRoutes {
if r.MW == addr {
return r.Cat, true
}
}
return "", false
}
// MWRouteCount 返回路由记录总数(校验用:应为 45)。
func MWRouteCount() int { return len(mwRoutes) }
// TotalValueCount 返回 §4.4 数值总数(校验用;A92+B~73+C72+D~79)。
func TotalValueCount() int {
n := 0
for _, r := range mwRoutes {
n += len(r.Tgts)
}
return n
}
// ParseSrcType 把字符串("G"/"C")解析为 SrcType,非法返回 false。
func ParseSrcType(s string) (SrcType, bool) {
t := SrcType(s)
if t == SrcStation || t == SrcMain {
return t, true
}
return "", false
}
// routeSrcType 由路由类别推断源类型(A/B 源=工位,C/D 源=主线)。
func routeSrcType(cat RouteCategory) (SrcType, bool) {
switch cat {
case CatA, CatB:
return SrcStation, true
case CatC, CatD:
return SrcMain, true
}
return "", false
}
// categoryTargetType 由路由类别推断目标类型(A/D 目标=主线,B/C 目标=工位)。
func categoryTargetType(cat RouteCategory) SrcType {
switch cat {
case CatA, CatD:
return SrcMain // G→C, C→C
case CatB, CatC:
return SrcStation // G→G, C→G
}
return ""
}
// TargetOption 手动下发目标下拉项(带类型,前端按 code 展示)。
type TargetOption struct {
Type SrcType
ID int
Code string
}
// MonitorTargets 返回某源允许的全部合法目标(跨该源涉及的多个类别合并),用于前端动态过滤下拉。
// 返回项带类型(Type)与编码(Code,如 "C5"/"G2"),前端据此提取目标类型参与预览/下发。
func MonitorTargets(srcType SrcType, src int) []TargetOption {
var out []TargetOption
for _, r := range mwRoutes {
rt, ok := routeSrcType(r.Cat)
if !ok || rt != srcType || r.Src != src {
continue
}
tgtType := categoryTargetType(r.Cat)
for _, t := range r.Tgts {
out = append(out, TargetOption{Type: tgtType, ID: t, Code: string(tgtType) + strconv.Itoa(t)})
}
}
sort.Slice(out, func(i, j int) bool {
if out[i].Type != out[j].Type {
return out[i].Type < out[j].Type // C 在前,G 在后
}
return out[i].ID < out[j].ID
})
return out
}
// ---------- 强制写入白名单(块 D:PLC 强制写) ----------
// 仅开放路径指令区 MW800~886(§4.4 路由表覆盖区)与
// 控制区 0x1000~0x1003(4096~4099:选 PSET / 启动 / 选 JOB / 选 TASK)。
// 其余 MW 地址一律拒绝写入,避免误写设备关键寄存器。
const (
writeMWLow = 800
writeMWHigh = 886
writeCtrlLow = 0x1000 // 4096
writeCtrlHigh = 0x1003 // 4099
// maxForceMerkerByte S7 M 区强制写字节上限(M 位可能被 PLC 程序循环覆盖,不做更细白名单)。
maxForceMerkerByte = 65535
)
// IsWritableMW 判断某 MW 地址是否处于强制写入白名单内(块 D)。
func IsWritableMW(addr int) bool {
return (addr >= writeMWLow && addr <= writeMWHigh) ||
(addr >= writeCtrlLow && addr <= writeCtrlHigh)
}
// IsWritableMerkerByte 判断某 M 字节是否允许强制写(块 D)。M 位可能被 PLC 程序覆盖,仅校验地址上限。
func IsWritableMerkerByte(b int) bool {
return b >= 0 && b <= maxForceMerkerByte
}
// AllRouteAddrs 返回 §4.4 全部 MW 地址(去重升序),供监控页读当前值。
func AllRouteAddrs() []int {
out := make([]int, 0, len(mwRoutes))
for _, r := range mwRoutes {
out = append(out, r.MW)
}
sort.Ints(out)
return out
}
// ParseMW 由 MW 地址 + 当前值反查源/目标(值=源×100+目标),并校验该组合确实存在于路由表。
// 返回 (srcType, tgtType, src, tgt, ok)。ok=false 表示地址/值无法解析为合法路由(如误写或脏值)。
func ParseMW(addr, value int) (srcType, tgtType SrcType, src, tgt int, ok bool) {
cat, cok := MWCategory(addr)
if !cok {
return "", "", 0, 0, false
}
st, _ := routeSrcType(cat)
tt := categoryTargetType(cat)
src = value / 100
tgt = value % 100
if src < 1 || tgt < 1 {
return "", "", 0, 0, false
}
if _, _, vok := LookupRoute(st, src, tgt, tt); !vok {
return "", "", 0, 0, false
}
return st, tt, src, tgt, true
}
+117 -11
View File
@@ -13,18 +13,20 @@ import (
"bj_power_mes/internal/config"
)
// 西门子 S7 真读:48 位块(MB895..MB900,6 字节)覆盖产线点位信号。
// 位布局(按业务口径 2026-10 定稿,锚点 C15=M898.2):
// 西门子 S7 真读:48 位块(MB895..MB902,8 字节)覆盖产线点位信号。
//
// 位 0..11 G1..G12 工位托盘位(工位 n 的托盘传感器,QueryStationPallet 读)
// 位 12..26 C1..C15 主线缓存位(C15=M898.2 → 位 26)
// 位 27..46 DOCK01..DOCK20 工位接驳台托盘位(每工位 2 个,共 20)
// 位 47 JBT21 库房接驳台(AGV 取料位)
// 真点位表(现场 PLC 工程师确认,2026-10 定稿):
// - 工位托盘位 G1..G12 → 逻辑 0..11 (MB895.0..MB896.3)
// - 主线缓存位 C1..C15 → 逻辑 12..26 (MB896.4..MB898.2,C15=M898.2)
// - 工位接驳台托盘位 → 逻辑 27..47 (MB900.0..MB902.4)
// DOCK01..DOCK20 → MB900.0..MB901.7(逻辑 27..46)
// JBT21(库房接驳台)→ MB902.4(逻辑 47)
// - 读块 MB895..MB902 共 8 字节;其中 MB898.3..MB899.7(逻辑位 27..39)为保留/注释段,读入后丢弃。
//
// 注:真实点位表以现场 PLC 工程师确认为准;以下布局由 C15=M898.2 反推,已满足 48 位自洽。
// 逻辑 48 位索引 → 物理字节位偏移由 logicalToRaw 统一映射,ReadBits 经 decodeBits 还原。
const (
plcBlockStartByte = 895
plcBlockBytes = 6
plcBlockBytes = 8
plcReadTimeout = 30 * time.Second
)
@@ -120,11 +122,12 @@ func bit(buf []byte, offset int) bool {
return buf[offset/8]&(1<<(offset%8)) != 0
}
// dockOffset DOCK 编码 → 块内位偏移;JBT21 单独处理。
// dockOffset DOCK 编码 → 8 字节读块内的物理位偏移;JBT21 单独处理。
// 接驳台真实物理位落在 MB900.0..MB902.4(读块内偏移 40..60)。
func dockOffset(dockCode string) (int, bool) {
dockCode = strings.ToUpper(strings.TrimSpace(dockCode))
if dockCode == "JBT21" {
return 47, true
return 60, true // MB902.4
}
if !strings.HasPrefix(dockCode, "DOCK") {
return 0, false
@@ -133,7 +136,7 @@ func dockOffset(dockCode string) (int, bool) {
if err != nil || n < 1 || n > 20 {
return 0, false
}
return 27 + (n - 1), true
return 40 + (n - 1), true // DOCK01→40(M900.0) ... DOCK20→59(M901.7), JBT21→60(M902.4)
}
// tcpClient 真实 S7 对接实现(替换原 mock 占位)。
@@ -194,3 +197,106 @@ func (t *tcpClient) QueryStationPallet(ctx context.Context, stationNo int) (bool
}
return bit(buf, stationNo-1), nil
}
// logicalToRaw 逻辑 48 位索引 → 物理字节位偏移(8 字节读块内)。
// 工位(G)/主线(C) 段 0..26 物理与逻辑一致;接驳台段 27..47 物理落在 MB900.0..MB902.4(偏移 40..60)。
func logicalToRaw(o int) int {
if o < 27 {
return o
}
return o - 27 + 40
}
// decodeBits 把 8 字节原始读块还原为逻辑 48 位(工位/主线/接驳台),丢弃 M898.3~M899.7 保留段。
func decodeBits(buf []byte) []bool {
out := make([]bool, 48)
for i := 0; i < 48; i++ {
out[i] = bit(buf, logicalToRaw(i))
}
return out
}
// ReadBits 读 48 位点位信号(§4.1,一次性读取不轮询):
// 读 MB895..MB902 共 8 字节(64 位),经 logicalToRaw/decodeBits 还原为逻辑 48 位:
// [0..11]G1..G12 [12..26]C1..C15 [27..46]DOCK01..DOCK20 [47]JBT21(接驳台物理位 MB900.0~MB902.4)。
func (t *tcpClient) ReadBits(ctx context.Context) ([]bool, error) {
buf, err := t.real.readBlock(ctx)
if err != nil {
return nil, err
}
return decodeBits(buf), nil
}
// ReadMW 读 16 位寄存器(MW,大端):读 addr、addr+1 两字节拼成 16 位。
func (t *tcpClient) ReadMW(ctx context.Context, addr int) (int, error) {
hi, err := t.real.readByte(ctx, addr)
if err != nil {
return 0, err
}
lo, err := t.real.readByte(ctx, addr+1)
if err != nil {
return 0, err
}
return int(hi)<<8 | int(lo), nil
}
// WriteMW 写 16 位寄存器(MW,大端):高字节写 addr、低字节写 addr+1。
func (t *tcpClient) WriteMW(ctx context.Context, addr, value int) error {
buf := []byte{byte(value >> 8), byte(value & 0xff)}
return t.real.writeBuffer(ctx, addr, buf)
}
// WriteBit 强制写单个 M 位(MB merkerByte 的 merkerBit 位),返回写入前/写后即时回读值。
// 真实 S7:先读该字节、置/清对应位、整字节写回,再读回确认(M 位可能被 PLC 程序循环覆盖,after 仅反映即时态)。
// 仅用于停机/调试。
func (t *tcpClient) WriteBit(ctx context.Context, merkerByte, merkerBit int, on bool) (before, after bool, err error) {
if merkerByte < 0 || merkerBit < 0 || merkerBit > 7 {
return false, false, fmt.Errorf("非法的 M 位:MB%d.%d", merkerByte, merkerBit)
}
cur, err := t.real.readByte(ctx, merkerByte)
if err != nil {
return false, false, err
}
before = cur&(1<<merkerBit) != 0
if on {
cur |= 1 << merkerBit
} else {
cur &^= 1 << merkerBit
}
if err = t.real.writeBuffer(ctx, merkerByte, []byte{cur}); err != nil {
return before, before, err
}
// 写后即时回读(M 位可能被 PLC 程序覆盖,after 不保证持续有效)
if rb, rerr := t.real.readByte(ctx, merkerByte); rerr == nil {
after = rb&(1<<merkerBit) != 0
} else {
after = on
}
return before, after, nil
}
// writeBuffer 写任意 Merker 字节区间(供 WriteMW 调用),带惰性连接与断线重连。
func (s *s7Real) writeBuffer(ctx context.Context, byteOffset int, data []byte) error {
s.mu.Lock()
if err := s.ensure(); err != nil {
s.mu.Unlock()
return err
}
cl := s.client
s.mu.Unlock()
done := make(chan error, 1)
go func() { done <- cl.AGWriteMB(byteOffset, len(data), data) }()
select {
case <-ctx.Done():
return ctx.Err()
case err := <-done:
if err != nil {
s.mu.Lock()
_ = s.handler.Close()
s.client = nil
s.mu.Unlock()
return err
}
return nil
}
}
+124
View File
@@ -0,0 +1,124 @@
package plc
import (
"context"
"testing"
)
// setBit 在 8 字节缓冲的第 offset 位置 1(offset 0..63)。
func setBit(buf []byte, offset int) {
buf[offset/8] |= 1 << (offset % 8)
}
func TestLogicalToRaw(t *testing.T) {
// 工位/主线段:逻辑 == 物理
for i := 0; i < 27; i++ {
if got := logicalToRaw(i); got != i {
t.Fatalf("logicalToRaw(%d) = %d, want %d", i, got, i)
}
}
// 接驳台段:逻辑 27..47 → 物理 40..60
for i := 27; i < 48; i++ {
if got := logicalToRaw(i); got != i-27+40 {
t.Fatalf("logicalToRaw(%d) = %d, want %d", i, got, i-27+40)
}
}
}
func TestDecodeBits(t *testing.T) {
// 全 1:逻辑 0..26(27 位)+ 40..60(21 位)全部置位 → 48 位全 true
all := make([]byte, 8)
for i := range all {
all[i] = 0xFF
}
out := decodeBits(all)
for i := 0; i < 48; i++ {
if !out[i] {
t.Fatalf("decodeBits(all)[%d] = false, want true", i)
}
}
// 仅置物理位 27(M898.3,保留段):逻辑 48 位应全 false
buf := make([]byte, 8)
setBit(buf, 27)
out = decodeBits(buf)
for i := 0; i < 48; i++ {
if out[i] {
t.Fatalf("decodeBits(discarded bit 27)[%d] = true, want false (保留段不可见)", i)
}
}
// 仅置物理位 26(M898.2 = C15)→ 逻辑 26 true
buf = make([]byte, 8)
setBit(buf, 26)
out = decodeBits(buf)
if !out[26] {
t.Fatalf("decodeBits(M898.2)[26] = false, want true")
}
if out[27] {
t.Fatalf("decodeBits(M898.2)[27] 不应被接驳台段吞掉")
}
// 仅置物理位 40(M900.0 = DOCK01)→ 逻辑 27 true
buf = make([]byte, 8)
setBit(buf, 40)
out = decodeBits(buf)
if !out[27] {
t.Fatalf("decodeBits(M900.0)[27] = false, want true (DOCK01)")
}
// 仅置物理位 60(M902.4 = JBT21)→ 逻辑 47 true,46 false
buf = make([]byte, 8)
setBit(buf, 60)
out = decodeBits(buf)
if !out[47] {
t.Fatalf("decodeBits(M902.4)[47] = false, want true (JBT21)")
}
if out[46] {
t.Fatalf("decodeBits(M902.4)[46] = true, want false")
}
}
// TestIsWritableMW 块 D 白名单:MW800~886 + 4096~4099 可写,其余拒绝。
func TestIsWritableMW(t *testing.T) {
ok := []int{800, 805, 886, 4096, 4099}
bad := []int{799, 887, 900, 4095, 4100, 0, 4096 + 100, 10000}
for _, a := range ok {
if !IsWritableMW(a) {
t.Fatalf("IsWritableMW(%d) = false, want true", a)
}
}
for _, a := range bad {
if IsWritableMW(a) {
t.Fatalf("IsWritableMW(%d) = true, want false", a)
}
}
}
// TestIsWritableMerkerByte 块 D:M 字节地址范围校验。
func TestIsWritableMerkerByte(t *testing.T) {
if !IsWritableMerkerByte(895) || !IsWritableMerkerByte(0) || !IsWritableMerkerByte(65535) {
t.Fatal("合法 M 字节应放行")
}
if IsWritableMerkerByte(-1) || IsWritableMerkerByte(65536) {
t.Fatal("越界 M 字节应拒绝")
}
}
// TestMockWriteBit 块 D:强制写 M 位(mock)写前/写后值正确。
func TestMockWriteBit(t *testing.T) {
m := newMockClient()
// 初始无值
before, after, err := m.WriteBit(context.Background(), 898, 2, true)
if err != nil || before != false || after != true {
t.Fatalf("WriteBit 置位: before=%v after=%v err=%v", before, after, err)
}
before, after, err = m.WriteBit(context.Background(), 898, 2, false)
if err != nil || before != true || after != false {
t.Fatalf("WriteBit 复位: before=%v after=%v err=%v", before, after, err)
}
// 非法位
if _, _, err = m.WriteBit(context.Background(), 898, 8, true); err == nil {
t.Fatal("bit=8 应报错")
}
}