一、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 构建指纹更新
271 lines
12 KiB
Go
271 lines
12 KiB
Go
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)
|
||
}
|