feat(mes): AGV挂起动作引擎 + 智能跟车流转 + PLC快照缓存(2026-11-19 主控拍板)

一、AGV 挂起动作引擎(弃显式任务队列、弃并发硬拒)
- 新增 internal/logic/agv_pending.go:待发动作直接挂任务(pending_action + pending_since),
  CONTINUE_LIFT(举升完成→continueTask#1)/ WAIT_DROP_CONFIRM(人工确认放下→continueTask#2)
  / FREE_ROBOT(末组完成→freeRobot);系统动作超 60s 未触发转预警人工重试,绝不自动重发
- Client 新增 ContinueTask(RCS 2.1.2) / FreeRobot(3.1.2),仅点名释放指定车,禁止释放全部
- agv_task 增 pending_action/pending_since 字段,ent 重生成 + db.go 幂等迁移补丁 + migrateonce
- 回调按 B01/B02/C01 模板编排:业务流转到位即自动放行放下、回调自动放车;
  仅人工派车(MANUAL)挂 WAIT_DROP_CONFIRM;新增 /agv/confirm-drop、/agv/pending/retry
- 前端 AgvManual/Agv 确认放下、挂起重试按钮与等待提示联动

二、智能跟车 + 动态目标截断流转引擎
- 新增 internal/logic/flow_engine.go:事件驱动(报工/扫码),读 48 位物理快照,从下游往上游算,
  前方占用则动态截断到最近空闲缓存位;IN_TRANSIT 在途闭锁防重复下发,MW=0 才确认到位落台账;
  主线占用=台账 OR 传感器,工位 G 位只认台账;在途超 5s 落预警
- workpiece 增 flow_transit_mw/target/at 字段,ent 重生成 + 迁移补丁

三、PLC 读取优化与诊断
- 新增 internal/plc/snapshot_cache.go:2s TTL + singleflight + 写失效,合并 SSE/PLC监控/流转引擎
  的重复点位读取;tcp.go 读块重构、localip.go 多网卡、plcdiag 诊断工具、plc_monitor/logging 配套

四、文档与前端
- help.js 重写「工位下发」帮助:明确报工自动驱动流转 vs 下发路线码的定位、缺料/握手/撤回边界
- 案例.md 补充定稿说明;public/index.html 构建指纹更新
This commit is contained in:
SunYF
2026-11-19 23:08:46 +08:00
parent 4c4cda1d41
commit 9aaa768e6c
40 changed files with 3037 additions and 364 deletions
+233
View File
@@ -0,0 +1,233 @@
// Command plcdiag 分层诊断 PLC 通讯故障,定位「ping 通但读点位失败」的真实原因。
//
// 用法(在 bj_power_mes 根目录执行):
//
// go run ./tools/plcdiag
// go run ./tools/plcdiag -host 192.168.22.20 -port 102 -rack 0 -slot 1 -timeout 5
//
// 诊断分四层,任一层失败即定位问题所在:
//
// [1] 本机网卡 IP —— 确认已切到与 PLC 同段(192.168.22.x)
// [2] ICMP ping —— 网络层是否可达(ping 通只证明这一层)
// [3] TCP 102 端口 —— S7 服务端口是否可达(ping 通 ≠ 端口通,最常见故障点)
// [4] S7 握手 + 读 MB895 —— 协议 / 机架槽号 / 点位映射是否正确
package main
import (
"errors"
"flag"
"fmt"
"net"
"os/exec"
"runtime"
"strings"
"time"
"bj_power_mes/internal/netutil"
"github.com/robinson/gos7"
)
func main() {
host := flag.String("host", "192.168.22.20", "PLC IP 地址")
port := flag.Int("port", 102, "S7 TCP 端口(默认 102)")
rack := flag.Int("rack", 0, "S7 机架号(1200/300=0)")
slot := flag.Int("slot", 1, "S7 槽号(1200=1,300=2)")
sec := flag.Int("timeout", 5, "每层超时秒数(默认 5)")
flag.Parse()
timeout := time.Duration(*sec) * time.Second
addr := net.JoinHostPort(*host, fmt.Sprintf("%d", *port))
fmt.Println("========================================")
fmt.Println(" PLC 通讯分层诊断工具")
fmt.Printf(" 目标 PLC: %s rack=%d slot=%d 每层超时=%ds\n", addr, *rack, *slot, *sec)
fmt.Println("========================================")
stepLocalIP(addr)
ok2 := stepPing(*host, timeout)
ok3 := stepTCP(addr, timeout)
ok4 := stepS7(*host, *rack, *slot, timeout)
fmt.Println()
fmt.Println("========================================")
fmt.Println(" 诊断结论")
fmt.Println("========================================")
conclusion(ok2, ok3, ok4, *host)
fmt.Println()
fmt.Println("---------- 附:工位号越界(15)本地校验 ----------")
fmt.Println(" QueryStationPallet 合法工位号 = 1..12(G1..G12)。")
fmt.Println(" 15 越界;15 实际是主线缓存位 C15(MB898.2,逻辑位 26),不是工位。")
fmt.Println(" 该错误与网络无关,是本地参数校验:若切网后仍出现,请查是哪个页面把 15 当工位号传入。")
}
// [1] 列出本机所有非回环 IPv4,并用内核路由探测"连 PLC 实际走的出口 IP"。
func stepLocalIP(target string) bool {
fmt.Println("\n[1/4] 本机网卡 IPv4 + 连 PLC 实际出口 IP(内核路由探测)")
addrs, err := net.InterfaceAddrs()
if err != nil {
fmt.Println(" [FAIL] 读取本机网卡失败:", err)
return false
}
found := false
for _, a := range addrs {
ipnet, ok := a.(*net.IPNet)
if !ok || ipnet.IP.IsLoopback() {
continue
}
v4 := ipnet.IP.To4()
if v4 == nil {
continue
}
fmt.Printf(" - %s\n", v4.String())
found = true
}
if !found {
fmt.Println(" [FAIL] 未找到任何非回环 IPv4 地址,检查网卡是否启用")
return false
}
// 让内核按路由表选出"连目标 PLC 会用的源 IP"——与真实 TCP 连接同一张路由表。
outIP := netutil.LocalIPFor(target)
if outIP == "" {
fmt.Printf(" [WARN] 无法确定连 %s 的出口 IP(目标不可达或无路由)\n", target)
return false
}
fmt.Printf(" [出口] 连 %s 实际使用本机 IP: %s\n", target, outIP)
return true
}
// [2] 调系统 ping 命令测 ICMP(不引入额外依赖,Windows/Linux 均可用)。
func stepPing(host string, timeout time.Duration) bool {
fmt.Printf("\n[2/4] ICMP ping %s(网络层可达性)\n", host)
var cmd *exec.Cmd
if runtime.GOOS == "windows" {
cmd = exec.Command("ping", "-n", "2", "-w", fmt.Sprintf("%d", timeout.Milliseconds()), host)
} else {
cmd = exec.Command("ping", "-c", "2", "-W", fmt.Sprintf("%d", int(timeout.Seconds())), host)
}
out, err := cmd.CombinedOutput()
for _, line := range strings.Split(string(out), "\n") {
l := strings.TrimRight(line, "\r")
if l != "" {
fmt.Println(" |", l)
}
}
if err != nil {
fmt.Println(" [FAIL] ping 命令执行失败:", err)
return false
}
s := string(out)
if strings.Contains(s, "TTL=") || strings.Contains(s, "ttl=") ||
strings.Contains(s, "0% packet loss") || strings.Contains(s, "0 packets transmitted") {
fmt.Println(" [PASS] 网络层可达(ICMP 通)")
return true
}
fmt.Println(" [WARN] 未识别到明确成功标志,请人工核对上面输出")
return false
}
// [3] TCP 连接 S7 端口。ping 通 ≠ 102 端口通,这是最常见的故障分层。
func stepTCP(addr string, timeout time.Duration) bool {
fmt.Printf("\n[3/4] TCP 连接 %s(S7 服务端口,关键分层)\n", addr)
start := time.Now()
conn, err := net.DialTimeout("tcp", addr, timeout)
if err != nil {
fmt.Printf(" [FAIL] %s(耗时 %s)\n", classifyNetErr(err), time.Since(start).Round(time.Millisecond))
return false
}
defer conn.Close()
fmt.Printf(" [PASS] TCP 握手成功(耗时 %s)—— 端口可达\n", time.Since(start).Round(time.Millisecond))
return true
}
func classifyNetErr(err error) string {
var ne net.Error
if errors.As(err, &ne) && ne.Timeout() {
return "连接超时(timeout):多为网段不通/防火墙静默丢包 —— 重点确认本机 IP 与 PLC 是否同段"
}
low := strings.ToLower(err.Error())
switch {
case strings.Contains(low, "connection refused"), strings.Contains(low, "connectex"), strings.Contains(low, "econnrefused"):
return "连接被拒绝(refused):主机可达但 102 端口未监听或被防火墙拒绝"
case strings.Contains(low, "no route to host"), strings.Contains(low, "network is unreachable"),
strings.Contains(low, "enetiunreach"), strings.Contains(low, "unreachable"):
return "网络不可达:路由/网段/掩码错误 —— 检查本机 IP 与子网掩码"
default:
return err.Error()
}
}
// [4] 真正的 S7 握手 + 读 MB895..MB902 共 8 字节点位块,与生产 tcp.go 同参数同库。
func stepS7(host string, rack, slot int, timeout time.Duration) bool {
fmt.Printf("\n[4/4] S7 协议握手 + 读 MB895..MB902(8 字节点位块)\n")
handler := gos7.NewTCPClientHandler(host, rack, slot)
handler.Timeout = timeout
if err := handler.Connect(); err != nil {
fmt.Printf(" [FAIL] S7 握手失败: %v\n", err)
fmt.Println(" → TCP 通但握手失败:核对 rack/slot(1200=0/1,300=0/2)、PLC 是否允许 PG/PC 访问")
return false
}
defer func() { _ = handler.Close() }()
client := gos7.NewClient(handler)
buf := make([]byte, 8)
if err := client.AGReadMB(895, 8, buf); err != nil {
fmt.Printf(" [FAIL] 读 MB895 失败: %v\n", err)
fmt.Println(" → 检查 PLC 程序是否映射 MB895..MB902、以及读权限")
return false
}
fmt.Printf(" [PASS] 读块成功,原始字节(MB895..MB902): % X\n", buf)
printBits(buf)
return true
}
func printBits(buf []byte) {
fmt.Println(" ---- 解码后的点位([1]=有件/占用,[0]=空) ----")
fmt.Println(" 工位托盘位 G1..G12:")
for i := 1; i <= 12; i++ {
fmt.Printf(" G%-2d %s\n", i, mark(rawBit(buf, i-1)))
}
fmt.Println(" 主线缓存位 C1..C15:")
for i := 1; i <= 15; i++ {
fmt.Printf(" C%-2d %s\n", i, mark(rawBit(buf, 11+i)))
}
fmt.Println(" 工位接驳台 DOCK01..DOCK20 / 库房接驳台 JBT21:")
for i := 1; i <= 20; i++ {
fmt.Printf(" DOCK%02d %s\n", i, mark(rawBit(buf, 39+i)))
}
fmt.Printf(" JBT21 %s\n", mark(rawBit(buf, 60)))
}
func mark(on bool) string {
if on {
return "[1]"
}
return "[0]"
}
func rawBit(buf []byte, phys int) bool {
if phys < 0 || phys >= len(buf)*8 {
return false
}
return buf[phys/8]&(1<<(phys%8)) != 0
}
func conclusion(ok2, ok3, ok4 bool, host string) {
switch {
case ok4:
fmt.Println(" [结论] 全链路正常:网络 / 端口 / S7 协议 / 点位读取 全部 OK。")
fmt.Println(" 之前的报错就是当时未切到 192.168.22.x 段导致,切网后已恢复。")
case ok3 && !ok4:
fmt.Println(" [结论] TCP 102 通但 S7 读失败 → 协议层问题:")
fmt.Println(" 核对 rack/slot、PLC 的 PG/PC 通信权限、MB895 点位映射。")
case ok2 && !ok3:
fmt.Printf(" [结论] ping 通但 TCP 102 不通 → 这是最常见的情况!\n")
fmt.Println(" ping 只证明 ICMP 可达,S7 走的是 TCP 102。")
fmt.Println(" 多为:未切网/不同段、防火墙拦截 102 端口、PLC 102 服务未开。")
fmt.Println(" 切到 192.168.22.108 后重跑;若仍 FAIL 请查防火墙与 PLC 端口。")
case !ok2 && ok3:
fmt.Println(" [结论] ping 不通但 TCP 通(少见):ICMP 被禁但 S7 正常,可忽略 ping。")
default:
fmt.Printf(" [结论] 网络层就不通:确认本机 IP 已切到与 %s 同段(192.168.22.x)、网线/交换机是否正常。\n", host)
}
}