- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端 - MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流 - 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志 - MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整 - 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整 - 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
418 lines
19 KiB
Go
418 lines
19 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 对单个工件尝试推进一次。返回 (结果, 是否发生流转)。
|
||
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("工件不存在或已删除")
|
||
}
|
||
// 只有在产线上的工件参与自动流转(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" {
|
||
return stay("工件已在末端下料检测位 " + src.PointNo + ",等待人工取件")
|
||
}
|
||
// 工件正停在下一道工序的候选工位上 → 等待加工,不推进
|
||
if !doneAll && src.PointType == "STATION" && intsContains(cands, src.StationNo) {
|
||
return stay("工件在工序候选工位" + strconv.Itoa(src.StationNo) + "等待加工")
|
||
}
|
||
// 目标选择:真实候选工位优先(升序,首个「台账空闲 + 无其他在制工件」者);
|
||
// 无台账行=虚拟工位(负数前段工位)仅作兜底。
|
||
// 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
|
||
}
|
||
}
|
||
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 流转到真实工位/末端:下发路由 + 台账 OUT/IN + 工件台账 + 流水。
|
||
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.flowSend(ctx, srcType, srcNo, tgtNo, plc.SrcStation)
|
||
if !ok {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: tgtPt.PointNo, Mode: flowModeStay,
|
||
Msg: src.PointNo + "→" + tgtPt.PointNo + " 不在 §4.4 路由表内,滞留原地"}, false
|
||
}
|
||
if err := s.OccupyPoint(ctx, src.PointNo, sn, wp.OrderNo, operator, "OUT"); err != nil {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: tgtPt.PointNo, Mode: mode,
|
||
Msg: "已下发但原点位释放失败,请人工核对:" + err.Error()}, false
|
||
}
|
||
if err := s.OccupyPoint(ctx, tgtPt.PointNo, sn, wp.OrderNo, operator, "IN"); err != nil {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: tgtPt.PointNo, Mode: mode,
|
||
Msg: "原点位已释放但目标点位占用失败,请人工核对:" + err.Error()}, false
|
||
}
|
||
if _, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).SetAtStationNo(tgtNo).Save(ctx); err != nil {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: tgtPt.PointNo, Mode: mode,
|
||
Msg: "点位已流转但工件台账更新失败,请人工核对:" + err.Error()}, 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)+")",
|
||
map[string]any{"sn": sn, "orderNo": wp.OrderNo, "from": src.PointNo, "to": tgtPt.PointNo,
|
||
"mode": mode, "mw": mw, "value": value})
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: tgtPt.PointNo, Mode: mode,
|
||
Msg: flowModeMsg(mode, mw, value, src.PointNo, tgtPt.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
|
||
}
|
||
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, "流转至虚拟工位(无物理点位),纯台账流转")
|
||
s.ctx.EventLog.Write(ctx, "workpiece.flow.move", wp.OrderNo, operator, "workpiece", sn,
|
||
"自动流转至虚拟工位 "+strconv.Itoa(cand)+"(纯台账)",
|
||
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: "虚拟工位(无物理点位),纯台账流转"}, true
|
||
}
|
||
|
||
// flowToCacheOrStay 下游候选工位全部被占时的缓存策略分流(仅 strict 且源为工位时进缓存):
|
||
// 把工件送进源工位 CatA(G→C)可达的第一个空闲缓存位(CACHE)排队;无可达空位 → 落「缓存满载」
|
||
// 报警并滞留原地。physical 策略一律滞留原地(堵在原地)。
|
||
func (s *Service) flowToCacheOrStay(ctx context.Context, src *ent.LinePoint, wp *ent.Workpiece, sn, operator string, srcNo int) (*FlowMoveResult, bool) {
|
||
policy := s.CfgStr(ctx, CfgMultiOrderCachePolicy, "physical")
|
||
if policy != "strict" {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: flowModeStay,
|
||
Msg: "下游候选工位被占,多工单缓存策略=physical,工件滞留原地"}, false
|
||
}
|
||
// CatA 可达目标(已按编号升序)∩ 缓存位(CACHE 类型)∩ 台账空闲,按主线 seq 升序取第一个
|
||
for _, n := range plc.AllTargets(plc.SrcStation, srcNo, plc.SrcMain) {
|
||
pointNo := "C" + strconv.Itoa(n)
|
||
pt, err := s.ctx.EntClient.LinePoint.Query().Where(linepoint.PointNoEQ(pointNo)).First(ctx)
|
||
if err != nil || pt == nil || pt.PointType != "CACHE" || pt.Occupied {
|
||
continue
|
||
}
|
||
mode, mw, value, ok := s.flowSend(ctx, plc.SrcStation, srcNo, n, plc.SrcMain)
|
||
if !ok {
|
||
continue
|
||
}
|
||
if err := s.OccupyPoint(ctx, src.PointNo, sn, wp.OrderNo, operator, "OUT"); err != nil {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: mode,
|
||
Msg: "进缓存失败(原点位释放出错):" + err.Error()}, false
|
||
}
|
||
if err := s.OccupyPoint(ctx, pointNo, sn, wp.OrderNo, operator, "IN"); err != nil {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, Mode: mode,
|
||
Msg: "进缓存失败(占用缓存位出错):" + err.Error()}, false
|
||
}
|
||
if _, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).SetAtStationNo(0).Save(ctx); err != nil {
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: pointNo, Mode: mode,
|
||
Msg: "已进缓存但工件台账更新失败,请人工核对:" + err.Error()}, false
|
||
}
|
||
s.flowLifecycle(ctx, wp, sn, operator, srcNo,
|
||
"下游候选工位被占,按缓存策略=strict 进入缓存位排队(物理位置以点位台账为准)")
|
||
s.ctx.EventLog.Write(ctx, "workpiece.flow.cache", wp.OrderNo, operator, "workpiece", sn,
|
||
"下游被占,工件进入缓存位排队 "+src.PointNo+" → "+pointNo+"("+flowModeMsg(mode, mw, value, src.PointNo, pointNo)+")",
|
||
map[string]any{"sn": sn, "orderNo": wp.OrderNo, "from": src.PointNo, "to": pointNo,
|
||
"mode": mode, "mw": mw, "value": value, "policy": policy})
|
||
return &FlowMoveResult{Sn: sn, From: src.PointNo, To: pointNo, Cached: true, Mode: mode,
|
||
Msg: "下游候选工位被占,已进入缓存位 " + pointNo + " 排队;" + flowModeMsg(mode, mw, value, src.PointNo, pointNo)}, true
|
||
}
|
||
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)
|
||
}
|
||
|
||
// runChainLoop 全线连锁扫描:对台账中全部占用点位上的工件各尝试推进一次;
|
||
// 一轮内无任何进展即停(上游腾位 → 缓存/滞留工件被层层拉入靠轮次推进)。
|
||
// 仅记录发生了流转的结果。
|
||
func (s *Service) runChainLoop(ctx context.Context, operator string) []FlowMoveResult {
|
||
out := make([]FlowMoveResult, 0, 8)
|
||
for round := 0; round < flowChainMaxRounds; round++ {
|
||
pts, err := s.ctx.EntClient.LinePoint.Query().
|
||
Where(linepoint.Occupied(true)).Order(ent.Asc(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
|
||
}
|
||
|
||
// TriggerFlowChainForSn 单件触发(报工后自动调用):先把该工件连续推进到不能推为止,
|
||
// 再全线连锁扫描(本件移出腾出的位置供上游滞留/缓存工件层层拉入)。
|
||
func (s *Service) TriggerFlowChainForSn(ctx context.Context, sn, operator string) []FlowMoveResult {
|
||
out := make([]FlowMoveResult, 0, 4)
|
||
for i := 0; i < flowChainMaxRounds; i++ {
|
||
res, moved := s.flowMoveOnce(ctx, sn, operator)
|
||
if res != nil {
|
||
out = append(out, *res)
|
||
}
|
||
if !moved {
|
||
break
|
||
}
|
||
}
|
||
out = append(out, s.runChainLoop(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
|
||
}
|