Files
bj_power/bj_power_mes/internal/logic/flow_engine.go
T
SunYF 9aaa768e6c 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 构建指纹更新
2026-11-19 23:08:46 +08:00

271 lines
12 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 logic
import (
"context"
"fmt"
"strconv"
"strings"
"sync"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/alert"
"bj_power_mes/ent/linepoint"
"bj_power_mes/ent/workpiece"
"bj_power_mes/internal/plc"
)
// ============ 智能跟车 + 动态目标截断流转引擎(2026-11-19 主控拍板) ============
//
// 与旧 runChainLoop(无条件直发最终目标、不读传感器、无在途闭锁)的本质区别:
// 1. 事件驱动:只在报工 / 人工扫描时触发,无后台定时器;
// 2. 一次性读 48 位(ReadBitsCached,2s TTL + singleflight + 写失效)生成物理快照;
// 3. 从下游往上游逐个算,前方路径被占 → 把下发目标动态截断到"占用点之前的最后一个空闲缓存位";
// 4. IN_TRANSIT 状态机:下发后工件标记在途,期间绝不重复下发;读到 MW=0 才确认到位、落实台账;
// 5. 主线 C 位占用 = 台账 occupied OR 传感器=1(任一被占即视为占,保守防追尾);
// 工位 G 位占用只认台账(工位传感器转圈闪烁不可信,不采信)。
//
// 全局锁 flowEngineMu 包住「读快照 → 算截断 → 写 MW → 写台账」全过程,
// 并发报工串行化,杜绝两条路径交叉/重复下发。
// flowEngineMu 流转引擎全局互斥锁(进程级单例;Service 每请求新建,锁必须包级)。
var flowEngineMu sync.Mutex
// flowTransitTimeoutMs 在途到位确认超时(毫秒):下发 MW 后超过此时长仍未读到 MW=0 → 落预警转人工。
const flowTransitTimeoutMs = 5000
// stationOutMainC 工位 Gk 出料停靠位 C 编号(lineCDefs 权威):
// G1/G2→C1, G3/G4→C4, G5/G6→C7, G7/G8→C10, G9/G10→C13, G11/G12→C15。
var stationOutMainC = map[int]int{1: 1, 2: 1, 3: 4, 4: 4, 5: 7, 6: 7, 7: 10, 8: 10, 9: 13, 10: 13, 11: 15, 12: 15}
// cacheMainC 可缓存主线位(CACHE=true,lineCDefs 权威):C2/C3/C5/C6/C8/C9/C11/C12/C14。
var cacheMainC = map[int]bool{2: true, 3: true, 5: true, 6: true, 8: true, 9: true, 11: true, 12: true, 14: true}
// lineOccupancy 主线占用图:
// - 台账 occupied 为事实源;
// - 48 位快照 sensors 为主线的实时物理信号(工位 G 位传感器不采信)。
// cFree 采用保守口径:台账空闲 **且** 传感器=0 才算空闲。
type lineOccupancy struct {
byPointNo map[string]*ent.LinePoint
sensors []bool // 48 位:[12..26]=C1..C15
}
func (o *lineOccupancy) sensorMain(c int) bool {
if c < 1 || c > 15 {
return false
}
i := 12 + (c - 1)
return i >= 0 && i < len(o.sensors) && o.sensors[i]
}
// cFree 主线 C 位是否空闲(台账 + 传感器双确认,任一被占即视为占)。
func (o *lineOccupancy) cFree(c int) bool {
pt := o.byPointNo["C"+strconv.Itoa(c)]
ledgerBusy := pt != nil && pt.Occupied
return !ledgerBusy && !o.sensorMain(c)
}
// engineSnapshot 一次触发的公共输入:台账 + 48 位物理快照。
func (s *Service) engineSnapshot(ctx context.Context) (*lineOccupancy, error) {
pts, err := s.ctx.EntClient.LinePoint.Query().All(ctx)
if err != nil {
return nil, err
}
m := make(map[string]*ent.LinePoint, len(pts))
for i := range pts {
m[pts[i].PointNo] = pts[i]
}
var sensors []bool
if !s.ctx.PLC.IsMock() {
sensors, _ = s.ctx.PLC.ReadBitsCached(ctx) // 读失败不阻断:退化为仅台账口径
}
return &lineOccupancy{byPointNo: m, sensors: sensors}, nil
}
// truncateTarget 动态目标截断核心:
// 给定工件源(srcPt)、最终目标工位(finalStation)与主线占用图,返回本次应下发的目标。
//
// 返回 (tgtType, tgtNo, reach, why):
// - tgtType=SrcStation 且 tgtNo=finalStation:路径全清,直达最终工位;
// - tgtType=SrcMain 且 tgtNo=缓存位编号:前方被占,截断到占用点之前最近的空闲 CACHE 位;
// - reach=false:无可达路径 / 前方被占且之前无空闲缓存位 → 滞留原地。
//
// 路径定义:沿主线从源出料停靠位(含)到目标工位停靠位(含)之间的 C 位区间,单向从小到大。
// 目标工位停靠位是"到达即顶升进工位",本身不缓存 → 它只作为终点判定,不作为截断落点。
func (s *Service) truncateTarget(ctx context.Context, o *lineOccupancy, srcType plc.SrcType, srcNo, finalStation int) (plc.SrcType, int, bool, string) {
startC := 0
if srcType == plc.SrcMain {
startC = srcNo
} else {
startC = stationOutMainC[srcNo]
}
endC := stationOutMainC[finalStation]
if startC <= 0 || endC <= 0 {
return "", 0, false, "源或目标工位无主线出料停靠位映射"
}
if endC <= startC {
return "", 0, false, "目标停靠位不在此工位下游(同工位/虚拟工位),不走滚筒线截断"
}
// 路径上第一个被占主线位(起点自身排除;终点停靠位单独判)。
firstBlocked := 0
for c := startC + 1; c < endC; c++ {
if !o.cFree(c) {
firstBlocked = c
break
}
}
if !o.cFree(endC) {
firstBlocked = endC
}
if firstBlocked == 0 {
return plc.SrcStation, finalStation, true, "路径全清,直达最终工位"
}
// 前方被占 → 截断到 firstBlocked 之前最近的空闲 CACHE 位(> startC,且 §4.4 可达)。
for c := firstBlocked - 1; c > startC; c-- {
if !cacheMainC[c] || !o.cFree(c) {
continue
}
if _, _, ok := plc.LookupRoute(srcType, srcNo, c, plc.SrcMain); ok {
return plc.SrcMain, c, true, "前方 C" + strconv.Itoa(firstBlocked) + " 被占,截断到缓存位 C" + strconv.Itoa(c)
}
}
return "", 0, false, "前方 C" + strconv.Itoa(firstBlocked) + " 被占,且之前无可达空闲缓存位,滞留原地"
}
// flowDispatch 统一"下发路由 + 标记在途"入口(替代旧的"下发即落实台账")。
//
// 写 MW 成功后不立即改台账、不更新 atStationNo——工件进入 IN_TRANSIT,
// 等 confirmInTransit 读到 MW=0 才落实(台账始终反映物理真实)。
// 返回 (mode, mw, value, ok)。
func (s *Service) flowDispatch(ctx context.Context, wp *ent.Workpiece, sn, operator string,
srcType plc.SrcType, srcNo int, tgtType plc.SrcType, tgtNo int) (string, int, int, bool) {
mw, value, ok := plc.LookupRoute(srcType, srcNo, tgtNo, tgtType)
if !ok {
return "", 0, 0, false
}
mode := flowModePLC
writeOK := true
if s.ctx.PLC.IsMock() {
mode = flowModeMock
} else if err := s.ctx.PLC.Get().WriteMW(ctx, mw, value); err != nil {
// PLC 不可达:写失败 → 不标记在途,降级为纯台账闭环(沿用旧口径),避免件永久卡在途。
mode = flowModeLedger
writeOK = false
}
// mock 模式:写 MW 不会自动清零,直接"下发即到位"落实台账,不进 IN_TRANSIT。
if s.ctx.PLC.IsMock() {
s.settleDirect(ctx, wp, sn, operator, string(tgtType)+strconv.Itoa(tgtNo))
return mode, mw, value, true
}
if !writeOK {
// 真实 PLC 写失败:纯台账闭环,直接落实(不留在途)。
s.settleDirect(ctx, wp, sn, operator, string(tgtType)+strconv.Itoa(tgtNo))
return mode, mw, value, true
}
now := time.Now()
target := string(tgtType) + strconv.Itoa(tgtNo)
_, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).
SetFlowTransitMW(mw).SetFlowTransitTarget(target).SetFlowTransitAt(now).Save(ctx)
if err != nil {
// 标记失败:PLC 已下发但台账未记在途——落预警提示人工核对(不自动重发)。
s.ctx.EventLog.Write(ctx, "workpiece.flow.transit_mark_fail", wp.OrderNo, operator, "workpiece", sn,
fmt.Sprintf("MW%d=%d 已下发但在途标记失败,请人工核对:%v", mw, value, err),
map[string]any{"sn": sn, "mw": mw, "value": value})
}
return mode, mw, value, true
}
// settleDirect 模拟闭环下"下发即到位":源 OUT / 目标 IN / 更新 atStationNo,清任何在途标记。
func (s *Service) settleDirect(ctx context.Context, wp *ent.Workpiece, sn, operator, target string) {
if srcPt, err := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.Occupied(true), linepoint.CurrentSnEQ(sn)).First(ctx); err == nil && srcPt != nil {
_ = s.OccupyPoint(ctx, srcPt.PointNo, sn, wp.OrderNo, operator, "OUT")
}
if tgtPt, err := s.ctx.EntClient.LinePoint.Query().Where(linepoint.PointNoEQ(target)).First(ctx); err == nil && tgtPt != nil {
_ = s.OccupyPoint(ctx, target, sn, wp.OrderNo, operator, "IN")
}
atStation := 0
if strings.HasPrefix(target, "G") {
atStation, _ = strconv.Atoi(strings.TrimPrefix(target, "G"))
}
_, _ = s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).SetAtStationNo(atStation).
SetFlowTransitMW(0).SetFlowTransitTarget("").ClearFlowTransitAt().Save(ctx)
}
// confirmInTransit 到位确认:对全部 IN_TRANSIT 工件读对应 MW(穿透缓存),
// 读到 0(PLC 已把托盘送达并清零)→ 清在途标记 + 落实台账(源 OUT/目标 IN/atStationNo);
// 超时未到位 → 落预警,保持 IN_TRANSIT 转人工。工位传感器不参与。
func (s *Service) confirmInTransit(ctx context.Context, operator string) []string {
wps, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.FlowTransitMWGT(0)).All(ctx)
if err != nil || len(wps) == 0 {
return nil
}
confirmed := make([]string, 0, len(wps))
now := time.Now()
for _, wp := range wps {
val, rerr := s.ctx.PLC.Get().ReadMW(ctx, wp.FlowTransitMW)
if rerr != nil {
continue
}
if val != 0 {
if wp.FlowTransitAt != nil && now.Sub(*wp.FlowTransitAt) > time.Duration(flowTransitTimeoutMs)*time.Millisecond {
s.alertFlowTransitTimeout(ctx, wp)
}
continue
}
if err := s.settleInTransit(ctx, wp, operator); err == nil {
confirmed = append(confirmed, wp.Sn)
}
}
return confirmed
}
// settleInTransit 到位后台账落定:清在途标记,源 OUT、目标 IN、更新 atStationNo。
func (s *Service) settleInTransit(ctx context.Context, wp *ent.Workpiece, operator string) error {
target := strings.TrimSpace(wp.FlowTransitTarget)
mw := wp.FlowTransitMW
if target == "" {
_, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).
SetFlowTransitMW(0).SetFlowTransitTarget("").ClearFlowTransitAt().Save(ctx)
return err
}
if srcPt, err := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.Occupied(true), linepoint.CurrentSnEQ(wp.Sn)).First(ctx); err == nil && srcPt != nil {
_ = s.OccupyPoint(ctx, srcPt.PointNo, wp.Sn, wp.OrderNo, operator, "OUT")
}
if tgtPt, err := s.ctx.EntClient.LinePoint.Query().Where(linepoint.PointNoEQ(target)).First(ctx); err == nil && tgtPt != nil {
_ = s.OccupyPoint(ctx, target, wp.Sn, wp.OrderNo, operator, "IN")
}
atStation := 0
if strings.HasPrefix(target, "G") {
atStation, _ = strconv.Atoi(strings.TrimPrefix(target, "G"))
}
_, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).
SetAtStationNo(atStation).
SetFlowTransitMW(0).SetFlowTransitTarget("").ClearFlowTransitAt().Save(ctx)
if err == nil {
s.ctx.EventLog.Write(ctx, "workpiece.flow.arrive", wp.OrderNo, operator, "workpiece", wp.Sn,
fmt.Sprintf("在途到位确认:MW%d 读到 0,托盘已到 %s,台账落定", mw, target),
map[string]any{"sn": wp.Sn, "mw": mw, "target": target})
s.notifyDashboard()
}
return err
}
// alertFlowTransitTimeout 在途超时预警(同 SN 未读去重)。
func (s *Service) alertFlowTransitTimeout(ctx context.Context, wp *ent.Workpiece) {
has, err := s.ctx.EntClient.Alert.Query().
Where(alert.RefTypeEQ("flow_transit_timeout"), alert.RefIdEQ(wp.Sn), alert.StatusEQ("UNREAD")).Exist(ctx)
if err != nil || has {
return
}
msg := fmt.Sprintf("工件 %s 的在途指令 MW%d 超过 %d 秒仍未读到 0(目标 %s),请检查 PLC 物理动作或到 PLC 管理页强制清零。",
wp.Sn, wp.FlowTransitMW, flowTransitTimeoutMs/1000, wp.FlowTransitTarget)
_, _ = s.ctx.EntClient.Alert.Create().
SetRuleId(0).SetType("line_cache_full").SetLevel("warning").
SetTarget(wp.FlowTransitTarget).SetTitle(truncateUTF8(msg, 255)).SetContent(truncateUTF8(msg, 500)).
SetRefType("flow_transit_timeout").SetRefId(wp.Sn).SetStatus("UNREAD").Save(ctx)
}