Files
bj_power/bj_power_mes/internal/plc/route.go
T
SunYF b0c048d9aa feat: 新增收集式校验错误弹窗及工位报警语音播报
新增 ErrorListDialog 组件用于统一展示结构化校验错误信息,实现报错一次收全;新增工位报警语音播报功能,通过浏览器 SpeechSynthesis 播放本工位相关报警;调整物料类别及序列号字段文案,移除「其他」类别;新增工单实际开始字段及采集方式配置;优化 AGV 及 PlcSend 页签刷新逻辑;新增看板物料追溯及工位报警接口;删除 PLC 强制写 M 位及相关测试代码;同步数据库字段注释及补丁。
2026-10-20 16:36:26 +08:00

276 lines
7.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
}
// 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
}