Files
bj_power/bj_power_mes/internal/logic/flow_chain.go
T
SunYF 7b7d27d150 feat: 会话令牌与守卫、看板组件及工位终端功能完善
- 用户表扩展:MES/WMS user 实体新增字段,新增 active_token 迁移 SQL(2026-11-11)
- 会话机制:MES 新增 session_guard,重构 token/auth/jwt/perm 与路由;WMS/工作站同步令牌续签与鉴权
- 看板(board):调整 MES 看板产线/生产/侧栏/仓库组件及样式;WMS 看板展示页同步调整
- 工位终端后端:完善报警流、绑定、PLC 对账、拧紧、proxy、上报、站点告警/操作等 handler,补充 mes client/store
- 工位终端前端:登录/主界面/各操作面板调整,新增滚动分页与多语言 yaml 文案,刷新构建产物
- MES 业务:新增流程链 logic,调整待审核/产能支撑/产品工艺/设置页、PLC 监控与帮助文档,刷新构建产物
- 更新问题记录文档
2026-11-11 14:36:16 +08:00

388 lines
18 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
}
// flowStationBusy 该工位/末端是否被其他在制工件占用(按工件台账 atStationNo 判定,
// 口径与 plc_monitor 位置核对一致;DONE/SCRAPPED 不算占用)。
func (s *Service) flowStationBusy(ctx context.Context, stationNo int) bool {
exist, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.AtStationNoEQ(stationNo), workpiece.StatusNotIn("DONE", "SCRAPPED")).
Exist(ctx)
return err == nil && exist
}
// 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) + "等待加工")
}
// 目标选择:真实候选工位优先(升序,首个「台账空闲 + 无其他在制工件」者);
// 无台账行=虚拟工位(负数前段工位)仅作兜底。
var virtualCand *int
occupiedHit := false
for _, cand := range cands {
pt, has := s.flowStationPoint(ctx, cand)
if !has {
c := cand
virtualCand = &c
continue
}
if pt.Occupied || s.flowStationBusy(ctx, cand) {
occupiedHit = true
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)
}
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
}