300 lines
8.9 KiB
Go
300 lines
8.9 KiB
Go
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
|
||
}
|