Files
bj_power/bj_power_mes/internal/plc/route.go
T

300 lines
8.9 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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
}