新增 ErrorListDialog 组件用于统一展示结构化校验错误信息,实现报错一次收全;新增工位报警语音播报功能,通过浏览器 SpeechSynthesis 播放本工位相关报警;调整物料类别及序列号字段文案,移除「其他」类别;新增工单实际开始字段及采集方式配置;优化 AGV 及 PlcSend 页签刷新逻辑;新增看板物料追溯及工位报警接口;删除 PLC 强制写 M 位及相关测试代码;同步数据库字段注释及补丁。
276 lines
7.9 KiB
Go
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
|
|
}
|