Files
bj_power/bj_power_mes/internal/logic/flow_chain.go
T
SunYF d92ca803d5 feat: 来料检处置项实体与复检、日排产达成对比、PLC/WMS 传输日志
- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端
- MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流
- 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志
- MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整
- 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整
- 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
2026-11-16 16:42:44 +08:00

418 lines
19 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 对单个工件尝试推进一次。返回 (结果, 是否发生流转)。
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
}