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