Files
bj_power/bj_power_mes/internal/logic/flow_chain.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

448 lines
20 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"
"bj_power_mes/ent"
"bj_power_mes/ent/alert"
"bj_power_mes/ent/linepoint"
"bj_power_mes/ent/workorder"
"bj_power_mes/ent/workpiece"
"bj_power_mes/internal/plc"
)
// ============ 报工后自动流转连锁(triggerFlowChain,2026-11-11 拍板) ============
//
// 报工完成后,工件物理位置自动推进:
// 1. 有下一道工艺:送该工艺候选工位中首个「台账空闲 + 无其他在制工件 + §4.4 路由可达」的工位;
// 2. 全部工艺完成:送末端下料检测位(END-U=工位11 / END-D=工位12);
// 3. 下游候选工位全部被占:按基础设置 cache.multi.order.policy(CfgMultiOrderCachePolicy)
// —— strict=把工件送进源工位可达的第一个空闲缓存位(CACHE:C2/C3/C5/C6/C8/C9/C11/C12/C14)
// 排队,无可达空位则落「缓存满载」报警并滞留原地;physical=直接堵在原地不动;
// 4. 本件移出腾出的位置供上游滞留/缓存工件层层拉入(runChainLoop,无进展即停);
// 5. 模拟模式(PLC mock)或真实 PLC 写失败:模拟闭环——只改台账不发真实指令,
// 状态与真实模式口径一致(Mode=MOCK/LEDGER 区分)。
//
// 手动触发:POST /api/v1/plc/flow-scan(ScanFlowChain)走同一套 flowMoveOnce 逻辑全线扫描。
// 流转执行方式
const (
flowModePLC = "PLC" // 真实 PLC 下发成功
flowModeMock = "MOCK" // 模拟模式:不下发真实指令,台账与真实模式口径一致
flowModeLedger = "LEDGER" // 纯台账流转(PLC 不可达/写失败模拟闭环,或虚拟工位无物理点位)
flowModeStay = "STAY" // 滞留原地
)
// flowChainMaxRounds 连锁扫描最大轮数(防异常数据导致死循环)
const flowChainMaxRounds = 30
// FlowMoveResult 一次流转尝试的结果。
type FlowMoveResult struct {
Sn string `json:"sn"` // 工件 SN
From string `json:"from"` // 流转前点位(如 G3 / C5)
To string `json:"to,omitempty"` // 流转后点位(滞留为空)
Cached bool `json:"cached"` // 是否进了缓存位排队
Mode string `json:"mode"` // PLC / MOCK / LEDGER / STAY
Msg string `json:"msg,omitempty"`
}
// flowSrcInfo 由点位台账行推断流转源类型与编号(plc.LookupRoute 入参):
// STATION/END 行(工位/末端)→ SrcStation + stationNo;主线 C 位(pointNo="C5"…)→ SrcMain + 编号。
func flowSrcInfo(pt *ent.LinePoint) (plc.SrcType, int, bool) {
if pt == nil {
return "", 0, false
}
switch pt.PointType {
case "STATION", "END":
if pt.StationNo >= 1 {
return plc.SrcStation, pt.StationNo, true
}
return "", 0, false
}
if strings.HasPrefix(pt.PointNo, "C") {
if n, err := strconv.Atoi(strings.TrimPrefix(pt.PointNo, "C")); err == nil && n >= 1 {
return plc.SrcMain, n, true
}
}
return "", 0, false
}
// flowStationPoint 工位/末端对应的台账行(STATION/END 类型按 stationNo 定位);
// 无台账行(如负数虚拟工位)返回 false。
func (s *Service) flowStationPoint(ctx context.Context, stationNo int) (*ent.LinePoint, bool) {
pts, err := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.PointTypeIn("STATION", "END"), linepoint.StationNoEQ(stationNo)).
Order(ent.Asc(linepoint.FieldSeq)).All(ctx)
if err != nil || len(pts) == 0 {
return nil, false
}
return pts[0], true
}
// flowStationBusyBy 工位台面占用判定(2026-11-16 工位物理互斥):
// 滚筒线单件流,工位台面同一时间只能放一个工件。按工件台账 atStationNo 判定,
// 口径与 plc_monitor 位置核对一致;DONE/SCRAPPED 不算占用。
// 返回:台面是否被占、占用件所属工单号。占用件属于其他工单 → 本件不准流入,在缓存位排队。
func (s *Service) flowStationBusyBy(ctx context.Context, stationNo int, orderNo string) (bool, string, error) {
wps, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.AtStationNoEQ(stationNo), workpiece.StatusNotIn("DONE", "SCRAPPED")).
All(ctx)
if err != nil {
return false, "", err
}
for _, w := range wps {
if w.OrderNo != orderNo {
return true, w.OrderNo, nil
}
}
if len(wps) > 0 {
return true, "", nil // 台面被本工单在制件占用,同样放不进第二件
}
return false, "", nil
}
// flowSend 按 §4.4 路由表下发流转指令,返回执行方式:
// - 路由不可达 → ok=false;
// - 模拟模式(mock)→ Mode=MOCK,不发真实指令;
// - 真实模式写失败(PLC 不可达)→ Mode=LEDGER 模拟闭环(只改台账);
// - 真实模式写成功 → Mode=PLC。
func (s *Service) flowSend(ctx context.Context, srcType plc.SrcType, srcNo, tgtNo int, tgtType plc.SrcType) (mode string, mw, value int, ok bool) {
mw, value, ok = plc.LookupRoute(srcType, srcNo, tgtNo, tgtType)
if !ok {
return "", 0, 0, false
}
if s.ctx.PLC.IsMock() {
return flowModeMock, mw, value, true
}
if err := s.ctx.PLC.Get().WriteMW(ctx, mw, value); err != nil {
return flowModeLedger, mw, value, true
}
return flowModePLC, mw, value, true
}
// flowModeMsg 按执行方式生成结果文案。
func flowModeMsg(mode string, mw, value int, from, to string) string {
switch mode {
case flowModePLC:
return fmt.Sprintf("已下发 PLC 路由 %s→%s(MW%d=%d)", from, to, mw, value)
case flowModeMock:
return fmt.Sprintf("模拟模式:模拟流转 %s→%s(MW%d=%d,不发真实指令)", from, to, mw, value)
case flowModeLedger:
return fmt.Sprintf("PLC 下发失败/不可达,模拟闭环仅记台账 %s→%s(MW%d=%d)", from, to, mw, value)
}
return ""
}
// flowLifecycle 流转状态流水(action=FLOW)。
func (s *Service) flowLifecycle(ctx context.Context, wp *ent.Workpiece, sn, operator string, stationNo int, remark string) {
_, _ = s.ctx.EntClient.WorkpieceLifecycleLog.Create().
SetSn(sn).SetWorkOrderNo(wp.OrderNo).SetAction("FLOW").
SetFromStatus(wp.Status).SetToStatus(wp.Status).
SetStationNo(stationNo).SetOperator(operator).SetSource("auto_flow").
SetRemark(remark).Save(ctx)
}
// flowMoveOnce 对单个工件尝试推进一次。返回 (结果, 是否发生流转)。
// 2026-11-19:接入智能跟车引擎——在途件跳过、目标动态截断、下发标记在途。
func (s *Service) flowMoveOnce(ctx context.Context, sn, operator string) (*FlowMoveResult, bool) {
stay := func(msg string) (*FlowMoveResult, bool) {
return &FlowMoveResult{Sn: sn, Mode: flowModeStay, Msg: msg}, false
}
wp, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.SnEQ(sn)).First(ctx)
if err != nil {
return stay("工件不存在或已删除")
}
// IN_TRANSIT:已下发未到位,期间绝不重复下发(防撞核心),等 confirmInTransit 确认。
if wp.FlowTransitMW > 0 {
return stay("工件在途(MW" + strconv.Itoa(wp.FlowTransitMW) + "),等待到位确认,不重复下发")
}
// 只有在产线上的工件参与自动流转(NEW 未上线、SEMI_STORED 暂存在库、DONE/SCRAPPED 终态均不动)
if wp.Status != "ONLINE" && wp.Status != "PROCESSING" {
return stay("状态 " + wp.Status + " 不参与自动流转")
}
src, err := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.Occupied(true), linepoint.CurrentSnEQ(sn)).
Order(ent.Asc(linepoint.FieldSeq)).First(ctx)
if err != nil {
if ent.IsNotFound(err) {
return stay("点位台账中无该工件的占用记录")
}
return stay("查询点位台账失败:" + err.Error())
}
wo, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNoEQ(wp.OrderNo)).First(ctx)
if err != nil {
return stay("所属工单不存在:" + wp.OrderNo)
}
route, err := FlowRouteOfWO(ctx, s.ctx.EntClient, wo)
if err != nil || len(route) == 0 {
return stay("工单未配置工艺组合,无法推导下一道工艺")
}
nextSeq, doneAll := s.firstUndoneFlowSeq(ctx, s.ctx.EntClient, sn, route)
var cands []int
if doneAll {
// 全部工艺完成 → 末端下料检测位(G11/G12)
cands = []int{11, 12}
} else {
for i := range route {
if route[i].Seq == nextSeq {
cands = append(cands, route[i].Stations...)
break
}
}
if len(cands) == 0 {
return stay("未找到下一道工艺的候选工位")
}
}
srcType, srcNo, sok := flowSrcInfo(src)
if !sok {
return stay("点位 " + src.PointNo + " 无法确定流转源类型")
}
if src.PointType == "END" {
// 工位11/12(末端下料检测位)兼容逻辑原样保留:等待人工取件,不参与滚筒线截断。
return stay("工件已在末端下料检测位 " + src.PointNo + ",等待人工取件")
}
// 工件正停在下一道工艺的候选工位上 → 等待加工,不推进
if !doneAll && src.PointType == "STATION" && intsContains(cands, src.StationNo) {
return stay("工件在工艺候选工位" + strconv.Itoa(src.StationNo) + "等待加工")
}
// 智能跟车占用图(台账 + 48 位快照)。虚拟工位无物理点位,不走截断。
o, oerr := s.engineSnapshot(ctx)
if oerr != nil {
return stay("加载产线占用图失败:" + oerr.Error())
}
// 目标选择:真实候选工位优先(升序,首个「台账空闲 + 无其他在制工件」者);
// 无台账行=虚拟工位(负数前段工位)仅作兜底。
// 2026-11-16 工位物理互斥:滚筒线单件流,工位台面被其他工单在制件占用 → 不准流入,
// 件留在缓存位/原地排队(下游 flowToCacheOrStay / stay)。末端下料位(END)豁免互斥。
var virtualCand *int
occupiedHit := false
occupiedHint := ""
for _, cand := range cands {
pt, has := s.flowStationPoint(ctx, cand)
if !has {
c := cand
virtualCand = &c
continue
}
if pt.Occupied {
occupiedHit = true
continue
}
if pt.PointType != "END" {
busy, otherOrder, err := s.flowStationBusyBy(ctx, cand, wp.OrderNo)
if err == nil && busy {
occupiedHit = true
if otherOrder != "" {
occupiedHint = "工位" + strconv.Itoa(cand) + "正在加工工单" + otherOrder +
"的工件,须等其流转走后本件才能进入,已在缓存位排队等待"
}
continue
}
}
// 智能跟车:先算路径截断。全清→直达目标工位;前方被占→截断到最近空闲缓存位;无位→滞留。
tgtType, tgtNo, reach, why := s.truncateTarget(ctx, o, srcType, srcNo, cand)
if !reach {
return stay(why)
}
if tgtType == plc.SrcMain {
// 截断进缓存位:走缓存下发(标记在途)。
pointNo := "C" + strconv.Itoa(tgtNo)
return s.flowDispatchToCache(ctx, src, wp, sn, operator, srcType, srcNo, tgtNo, pointNo, why)
}
return s.flowExecMove(ctx, src, wp, sn, srcType, srcNo, pt, operator, doneAll)
}
if virtualCand != nil {
return s.flowLedgerVirtualMove(ctx, src, wp, sn, *virtualCand, operator)
}
// 下游候选工位全部被占 → 缓存策略(仅 strict 且源为工位时进缓存排队)
if occupiedHit && srcType == plc.SrcStation && !doneAll {
return s.flowToCacheOrStay(ctx, src, wp, sn, operator, srcNo)
}
if occupiedHint != "" {
return stay(occupiedHint)
}
return stay("下一道工艺候选工位均不可达/不可用,滞留原地")
}
// flowExecMove 流转到真实工位/末端:下发路由 + 标记 IN_TRANSIT(台账在到位确认后才落实)。
// 2026-11-19:不再"下发即改台账",避免件还在途中台账就显示已到、造成跟车误判。
func (s *Service) flowExecMove(ctx context.Context, src *ent.LinePoint, wp *ent.Workpiece, sn string,
srcType plc.SrcType, srcNo int, tgtPt *ent.LinePoint, operator string, doneAll bool) (*FlowMoveResult, bool) {
tgtNo := tgtPt.StationNo
mode, mw, value, ok := s.flowDispatch(ctx, wp, sn, operator, srcType, srcNo, plc.SrcStation, tgtNo)
if !ok {
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: tgtPt.PointNo, Mode: flowModeStay,
Msg: src.PointNo + "→" + tgtPt.PointNo + " 不在 §4.4 路由表内,滞留原地"}, false
}
remark := "报工后自动流转(在途) " + src.PointNo + " → " + tgtPt.PointNo
if doneAll {
remark = "全部工艺完成,自动流转至末端下料位(在途)"
}
s.flowLifecycle(ctx, wp, sn, operator, tgtNo, remark)
s.ctx.EventLog.Write(ctx, "workpiece.flow.move", wp.OrderNo, operator, "workpiece", sn,
"报工后自动下发 "+src.PointNo+" → "+tgtPt.PointNo+"("+flowModeMsg(mode, mw, value, src.PointNo, tgtPt.PointNo)+",等待 MW 到位确认)",
map[string]any{"sn": sn, "orderNo": wp.OrderNo, "from": src.PointNo, "to": tgtPt.PointNo,
"mode": mode, "mw": mw, "value": value, "transit": true})
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: tgtPt.PointNo, Mode: mode,
Msg: flowModeMsg(mode, mw, value, src.PointNo, tgtPt.PointNo) + ",等待到位确认"}, true
}
// flowDispatchToCache 截断到缓存位:下发 G/C→C 路由 + 标记 IN_TRANSIT。
func (s *Service) flowDispatchToCache(ctx context.Context, src *ent.LinePoint, wp *ent.Workpiece, sn, operator string,
srcType plc.SrcType, srcNo, tgtC int, pointNo, why string) (*FlowMoveResult, bool) {
mode, mw, value, ok := s.flowDispatch(ctx, wp, sn, operator, srcType, srcNo, plc.SrcMain, tgtC)
if !ok {
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: flowModeStay,
Msg: why + ",但该缓存位 §4.4 路由不可达,滞留原地"}, false
}
s.flowLifecycle(ctx, wp, sn, operator, 0, why+",下发进缓存位 "+pointNo+"(在途)")
s.ctx.EventLog.Write(ctx, "workpiece.flow.cache", wp.OrderNo, operator, "workpiece", sn,
why+" → "+pointNo+"("+flowModeMsg(mode, mw, value, src.PointNo, pointNo)+",等待 MW 到位确认)",
map[string]any{"sn": sn, "orderNo": wp.OrderNo, "from": src.PointNo, "to": pointNo,
"mode": mode, "mw": mw, "value": value, "transit": true, "truncate": true})
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: pointNo, Cached: true, Mode: mode,
Msg: why + ",已下发进缓存位 " + pointNo + ",等待到位确认"}, true
}
// flowLedgerVirtualMove 虚拟工位(负数前段工位,无台账行/无物理点位):纯台账流转。
func (s *Service) flowLedgerVirtualMove(ctx context.Context, src *ent.LinePoint, wp *ent.Workpiece, sn string, cand int, operator string) (*FlowMoveResult, bool) {
if err := s.OccupyPoint(ctx, src.PointNo, sn, wp.OrderNo, operator, "OUT"); err != nil {
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: flowModeStay,
Msg: "虚拟工位流转失败(原点位释放出错):" + err.Error()}, false
}
// 物理下线(2026-11-18 用户拍板):虚拟工位无物理点位,件实体下线 → 下发 PLC 送末端下料位
// (END-U 台账空闲走 G11,被占走 G12)。末端不落台账——件由虚拟工位台账(at_station_no)追踪,
// 后续工艺报工在虚拟工位终端做,与件物理上停在 11 还是 12 无关。
tgtNo := 11
if pt, e := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.PointType("END"), linepoint.PointNoEQ("END-U"), linepoint.Occupied(true)).
First(ctx); e == nil && pt != nil {
tgtNo = 12
}
physMsg := ""
if (src.PointType == "STATION" || src.PointType == "END") && src.StationNo >= 1 && src.StationNo <= 10 {
if _, _, _, ok := s.flowSend(ctx, plc.SrcStation, src.StationNo, tgtNo, plc.SrcStation); ok {
physMsg = ",实体已下发流转至末端下料位 G" + strconv.Itoa(tgtNo)
}
}
if _, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).SetAtStationNo(cand).Save(ctx); err != nil {
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: flowModeStay,
Msg: "虚拟工位流转失败(工件台账更新出错):" + err.Error()}, false
}
label := "虚拟工位" + strconv.Itoa(cand)
s.flowLifecycle(ctx, wp, sn, operator, cand, "流转至虚拟工位(无物理点位),纯台账流转"+physMsg)
s.ctx.EventLog.Write(ctx, "workpiece.flow.move", wp.OrderNo, operator, "workpiece", sn,
"自动流转至虚拟工位 "+strconv.Itoa(cand)+"(台账流转"+physMsg+")",
map[string]any{"sn": sn, "orderNo": wp.OrderNo, "from": src.PointNo, "to": label, "mode": flowModeLedger})
s.notifyDashboard()
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: label, Mode: flowModeLedger,
Msg: "虚拟工位(无物理点位),台账流转" + physMsg}, true
}
// flowToCacheOrStay 下游候选工位被占时的进缓存兜底(2026-11-19 智能跟车):
// 无条件把工件送进源工位可达的第一个空闲缓存位(台账空闲 + 传感器=0)排队,标记在途;
// 无可达空位 → 落「缓存满载」报警并滞留原地。
// 不再区分 physical/strict——动态截断已是常态机制,缓存位是唯一的"可停留"节点。
func (s *Service) flowToCacheOrStay(ctx context.Context, src *ent.LinePoint, wp *ent.Workpiece, sn, operator string, srcNo int) (*FlowMoveResult, bool) {
o, oerr := s.engineSnapshot(ctx)
if oerr != nil {
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: flowModeStay,
Msg: "加载产线占用图失败:" + oerr.Error()}, false
}
// CatA 可达目标(已按编号升序)∩ 缓存位(CACHE)∩ 空闲(台账+传感器),按主线编号升序取第一个。
for _, n := range plc.AllTargets(plc.SrcStation, srcNo, plc.SrcMain) {
pointNo := "C" + strconv.Itoa(n)
if !cacheMainC[n] || !o.cFree(n) {
continue
}
return s.flowDispatchToCache(ctx, src, wp, sn, operator, plc.SrcStation, srcNo, n, pointNo,
"下游候选工位被占,进入缓存位排队")
}
s.alertLineCacheFull(ctx, sn, src, srcNo)
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: flowModeStay,
Msg: "下游候选工位被占且缓存区无可达空位,工件滞留原地(已落缓存满载报警)"}, false
}
// alertLineCacheFull 缓存满载报警(type=line_cache_full,refType=flow_cache_full + refId=sn
// 去重:同一工件存在未读报警时不再重复落)。
func (s *Service) alertLineCacheFull(ctx context.Context, sn string, src *ent.LinePoint, srcNo int) {
msg := fmt.Sprintf("产线缓存满载:工件 %s 流转时下游工艺候选工位全部被占,且工位%d 可达的缓存位(C2/C3/C5/C6/C8/C9/C11/C12/C14)均无空位,工件滞留 %s,请人工干预或清理下游工位。",
sn, srcNo, src.PointNo)
has, err := s.ctx.EntClient.Alert.Query().
Where(alert.RefTypeEQ("flow_cache_full"), alert.RefIdEQ(sn), alert.StatusEQ("UNREAD")).
Exist(ctx)
if err != nil || has {
return
}
_, _ = s.ctx.EntClient.Alert.Create().
SetRuleId(0).SetType("line_cache_full").SetLevel("warning").
SetTarget(src.PointNo).SetTitle(truncateUTF8(msg, 255)).SetContent(truncateUTF8(msg, 500)).
SetRefType("flow_cache_full").SetRefId(sn).SetStatus("UNREAD").Save(ctx)
}
// runChainLoopLocked 全线连锁扫描(调用方已持 flowEngineMu):
// 每轮先做到位确认,再从下游往上游(seq 降序)逐个推进;无进展即停。
func (s *Service) runChainLoopLocked(ctx context.Context, operator string) []FlowMoveResult {
out := make([]FlowMoveResult, 0, 8)
for round := 0; round < flowChainMaxRounds; round++ {
s.confirmInTransit(ctx, operator)
pts, err := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.Occupied(true)).Order(ent.Desc(linepoint.FieldSeq)).All(ctx)
if err != nil {
out = append(out, FlowMoveResult{Mode: flowModeStay, Msg: "扫描点位台账失败:" + err.Error()})
break
}
progress := 0
for _, pt := range pts {
sn := strings.TrimSpace(pt.CurrentSn)
if sn == "" {
continue
}
res, moved := s.flowMoveOnce(ctx, sn, operator)
if moved && res != nil {
out = append(out, *res)
progress++
}
}
if progress == 0 {
break
}
}
return out
}
// runChainLoop 全线扫描入口(持全局锁)。
func (s *Service) runChainLoop(ctx context.Context, operator string) []FlowMoveResult {
flowEngineMu.Lock()
defer flowEngineMu.Unlock()
return s.runChainLoopLocked(ctx, operator)
}
// TriggerFlowChainForSn 报工后单件触发(持全局锁):先确认在途 → 本件推进 → 全线从下游往上游连锁。
func (s *Service) TriggerFlowChainForSn(ctx context.Context, sn, operator string) []FlowMoveResult {
flowEngineMu.Lock()
defer flowEngineMu.Unlock()
out := make([]FlowMoveResult, 0, 4)
s.confirmInTransit(ctx, operator)
for i := 0; i < flowChainMaxRounds; i++ {
res, moved := s.flowMoveOnce(ctx, sn, operator)
if res != nil {
out = append(out, *res)
}
if !moved {
break
}
s.confirmInTransit(ctx, operator) // 本件已下发→模拟到位(真实由下轮/下次触发确认)
}
out = append(out, s.runChainLoopLocked(ctx, operator)...)
return out
}
// ScanFlowChain 手动全线扫描(POST /plc/flow-scan):与报工后自动连锁同一套逻辑。
func (s *Service) ScanFlowChain(ctx context.Context, operator string) ([]FlowMoveResult, error) {
return s.runChainLoop(ctx, operator), nil
}