package logic import ( "context" "fmt" "strconv" "strings" "sync" "time" "bj_power_mes/ent" "bj_power_mes/ent/alert" "bj_power_mes/ent/linepoint" "bj_power_mes/ent/workpiece" "bj_power_mes/internal/plc" ) // ============ 智能跟车 + 动态目标截断流转引擎(2026-11-19 主控拍板) ============ // // 与旧 runChainLoop(无条件直发最终目标、不读传感器、无在途闭锁)的本质区别: // 1. 事件驱动:只在报工 / 人工扫描时触发,无后台定时器; // 2. 一次性读 48 位(ReadBitsCached,2s TTL + singleflight + 写失效)生成物理快照; // 3. 从下游往上游逐个算,前方路径被占 → 把下发目标动态截断到"占用点之前的最后一个空闲缓存位"; // 4. IN_TRANSIT 状态机:下发后工件标记在途,期间绝不重复下发;读到 MW=0 才确认到位、落实台账; // 5. 主线 C 位占用 = 台账 occupied OR 传感器=1(任一被占即视为占,保守防追尾); // 工位 G 位占用只认台账(工位传感器转圈闪烁不可信,不采信)。 // // 全局锁 flowEngineMu 包住「读快照 → 算截断 → 写 MW → 写台账」全过程, // 并发报工串行化,杜绝两条路径交叉/重复下发。 // flowEngineMu 流转引擎全局互斥锁(进程级单例;Service 每请求新建,锁必须包级)。 var flowEngineMu sync.Mutex // flowTransitTimeoutMs 在途到位确认超时(毫秒):下发 MW 后超过此时长仍未读到 MW=0 → 落预警转人工。 const flowTransitTimeoutMs = 5000 // stationOutMainC 工位 Gk 出料停靠位 C 编号(lineCDefs 权威): // G1/G2→C1, G3/G4→C4, G5/G6→C7, G7/G8→C10, G9/G10→C13, G11/G12→C15。 var stationOutMainC = map[int]int{1: 1, 2: 1, 3: 4, 4: 4, 5: 7, 6: 7, 7: 10, 8: 10, 9: 13, 10: 13, 11: 15, 12: 15} // cacheMainC 可缓存主线位(CACHE=true,lineCDefs 权威):C2/C3/C5/C6/C8/C9/C11/C12/C14。 var cacheMainC = map[int]bool{2: true, 3: true, 5: true, 6: true, 8: true, 9: true, 11: true, 12: true, 14: true} // lineOccupancy 主线占用图: // - 台账 occupied 为事实源; // - 48 位快照 sensors 为主线的实时物理信号(工位 G 位传感器不采信)。 // cFree 采用保守口径:台账空闲 **且** 传感器=0 才算空闲。 type lineOccupancy struct { byPointNo map[string]*ent.LinePoint sensors []bool // 48 位:[12..26]=C1..C15 } func (o *lineOccupancy) sensorMain(c int) bool { if c < 1 || c > 15 { return false } i := 12 + (c - 1) return i >= 0 && i < len(o.sensors) && o.sensors[i] } // cFree 主线 C 位是否空闲(台账 + 传感器双确认,任一被占即视为占)。 func (o *lineOccupancy) cFree(c int) bool { pt := o.byPointNo["C"+strconv.Itoa(c)] ledgerBusy := pt != nil && pt.Occupied return !ledgerBusy && !o.sensorMain(c) } // engineSnapshot 一次触发的公共输入:台账 + 48 位物理快照。 func (s *Service) engineSnapshot(ctx context.Context) (*lineOccupancy, error) { pts, err := s.ctx.EntClient.LinePoint.Query().All(ctx) if err != nil { return nil, err } m := make(map[string]*ent.LinePoint, len(pts)) for i := range pts { m[pts[i].PointNo] = pts[i] } var sensors []bool if !s.ctx.PLC.IsMock() { sensors, _ = s.ctx.PLC.ReadBitsCached(ctx) // 读失败不阻断:退化为仅台账口径 } return &lineOccupancy{byPointNo: m, sensors: sensors}, nil } // truncateTarget 动态目标截断核心: // 给定工件源(srcPt)、最终目标工位(finalStation)与主线占用图,返回本次应下发的目标。 // // 返回 (tgtType, tgtNo, reach, why): // - tgtType=SrcStation 且 tgtNo=finalStation:路径全清,直达最终工位; // - tgtType=SrcMain 且 tgtNo=缓存位编号:前方被占,截断到占用点之前最近的空闲 CACHE 位; // - reach=false:无可达路径 / 前方被占且之前无空闲缓存位 → 滞留原地。 // // 路径定义:沿主线从源出料停靠位(含)到目标工位停靠位(含)之间的 C 位区间,单向从小到大。 // 目标工位停靠位是"到达即顶升进工位",本身不缓存 → 它只作为终点判定,不作为截断落点。 func (s *Service) truncateTarget(ctx context.Context, o *lineOccupancy, srcType plc.SrcType, srcNo, finalStation int) (plc.SrcType, int, bool, string) { startC := 0 if srcType == plc.SrcMain { startC = srcNo } else { startC = stationOutMainC[srcNo] } endC := stationOutMainC[finalStation] if startC <= 0 || endC <= 0 { return "", 0, false, "源或目标工位无主线出料停靠位映射" } if endC <= startC { return "", 0, false, "目标停靠位不在此工位下游(同工位/虚拟工位),不走滚筒线截断" } // 路径上第一个被占主线位(起点自身排除;终点停靠位单独判)。 firstBlocked := 0 for c := startC + 1; c < endC; c++ { if !o.cFree(c) { firstBlocked = c break } } if !o.cFree(endC) { firstBlocked = endC } if firstBlocked == 0 { return plc.SrcStation, finalStation, true, "路径全清,直达最终工位" } // 前方被占 → 截断到 firstBlocked 之前最近的空闲 CACHE 位(> startC,且 §4.4 可达)。 for c := firstBlocked - 1; c > startC; c-- { if !cacheMainC[c] || !o.cFree(c) { continue } if _, _, ok := plc.LookupRoute(srcType, srcNo, c, plc.SrcMain); ok { return plc.SrcMain, c, true, "前方 C" + strconv.Itoa(firstBlocked) + " 被占,截断到缓存位 C" + strconv.Itoa(c) } } return "", 0, false, "前方 C" + strconv.Itoa(firstBlocked) + " 被占,且之前无可达空闲缓存位,滞留原地" } // flowDispatch 统一"下发路由 + 标记在途"入口(替代旧的"下发即落实台账")。 // // 写 MW 成功后不立即改台账、不更新 atStationNo——工件进入 IN_TRANSIT, // 等 confirmInTransit 读到 MW=0 才落实(台账始终反映物理真实)。 // 返回 (mode, mw, value, ok)。 func (s *Service) flowDispatch(ctx context.Context, wp *ent.Workpiece, sn, operator string, srcType plc.SrcType, srcNo int, tgtType plc.SrcType, tgtNo int) (string, int, int, bool) { mw, value, ok := plc.LookupRoute(srcType, srcNo, tgtNo, tgtType) if !ok { return "", 0, 0, false } mode := flowModePLC writeOK := true if s.ctx.PLC.IsMock() { mode = flowModeMock } else if err := s.ctx.PLC.Get().WriteMW(ctx, mw, value); err != nil { // PLC 不可达:写失败 → 不标记在途,降级为纯台账闭环(沿用旧口径),避免件永久卡在途。 mode = flowModeLedger writeOK = false } // mock 模式:写 MW 不会自动清零,直接"下发即到位"落实台账,不进 IN_TRANSIT。 if s.ctx.PLC.IsMock() { s.settleDirect(ctx, wp, sn, operator, string(tgtType)+strconv.Itoa(tgtNo)) return mode, mw, value, true } if !writeOK { // 真实 PLC 写失败:纯台账闭环,直接落实(不留在途)。 s.settleDirect(ctx, wp, sn, operator, string(tgtType)+strconv.Itoa(tgtNo)) return mode, mw, value, true } now := time.Now() target := string(tgtType) + strconv.Itoa(tgtNo) _, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID). SetFlowTransitMW(mw).SetFlowTransitTarget(target).SetFlowTransitAt(now).Save(ctx) if err != nil { // 标记失败:PLC 已下发但台账未记在途——落预警提示人工核对(不自动重发)。 s.ctx.EventLog.Write(ctx, "workpiece.flow.transit_mark_fail", wp.OrderNo, operator, "workpiece", sn, fmt.Sprintf("MW%d=%d 已下发但在途标记失败,请人工核对:%v", mw, value, err), map[string]any{"sn": sn, "mw": mw, "value": value}) } return mode, mw, value, true } // settleDirect 模拟闭环下"下发即到位":源 OUT / 目标 IN / 更新 atStationNo,清任何在途标记。 func (s *Service) settleDirect(ctx context.Context, wp *ent.Workpiece, sn, operator, target string) { if srcPt, err := s.ctx.EntClient.LinePoint.Query(). Where(linepoint.Occupied(true), linepoint.CurrentSnEQ(sn)).First(ctx); err == nil && srcPt != nil { _ = s.OccupyPoint(ctx, srcPt.PointNo, sn, wp.OrderNo, operator, "OUT") } if tgtPt, err := s.ctx.EntClient.LinePoint.Query().Where(linepoint.PointNoEQ(target)).First(ctx); err == nil && tgtPt != nil { _ = s.OccupyPoint(ctx, target, sn, wp.OrderNo, operator, "IN") } atStation := 0 if strings.HasPrefix(target, "G") { atStation, _ = strconv.Atoi(strings.TrimPrefix(target, "G")) } _, _ = s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).SetAtStationNo(atStation). SetFlowTransitMW(0).SetFlowTransitTarget("").ClearFlowTransitAt().Save(ctx) } // confirmInTransit 到位确认:对全部 IN_TRANSIT 工件读对应 MW(穿透缓存), // 读到 0(PLC 已把托盘送达并清零)→ 清在途标记 + 落实台账(源 OUT/目标 IN/atStationNo); // 超时未到位 → 落预警,保持 IN_TRANSIT 转人工。工位传感器不参与。 func (s *Service) confirmInTransit(ctx context.Context, operator string) []string { wps, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.FlowTransitMWGT(0)).All(ctx) if err != nil || len(wps) == 0 { return nil } confirmed := make([]string, 0, len(wps)) now := time.Now() for _, wp := range wps { val, rerr := s.ctx.PLC.Get().ReadMW(ctx, wp.FlowTransitMW) if rerr != nil { continue } if val != 0 { if wp.FlowTransitAt != nil && now.Sub(*wp.FlowTransitAt) > time.Duration(flowTransitTimeoutMs)*time.Millisecond { s.alertFlowTransitTimeout(ctx, wp) } continue } if err := s.settleInTransit(ctx, wp, operator); err == nil { confirmed = append(confirmed, wp.Sn) } } return confirmed } // settleInTransit 到位后台账落定:清在途标记,源 OUT、目标 IN、更新 atStationNo。 func (s *Service) settleInTransit(ctx context.Context, wp *ent.Workpiece, operator string) error { target := strings.TrimSpace(wp.FlowTransitTarget) mw := wp.FlowTransitMW if target == "" { _, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID). SetFlowTransitMW(0).SetFlowTransitTarget("").ClearFlowTransitAt().Save(ctx) return err } if srcPt, err := s.ctx.EntClient.LinePoint.Query(). Where(linepoint.Occupied(true), linepoint.CurrentSnEQ(wp.Sn)).First(ctx); err == nil && srcPt != nil { _ = s.OccupyPoint(ctx, srcPt.PointNo, wp.Sn, wp.OrderNo, operator, "OUT") } if tgtPt, err := s.ctx.EntClient.LinePoint.Query().Where(linepoint.PointNoEQ(target)).First(ctx); err == nil && tgtPt != nil { _ = s.OccupyPoint(ctx, target, wp.Sn, wp.OrderNo, operator, "IN") } atStation := 0 if strings.HasPrefix(target, "G") { atStation, _ = strconv.Atoi(strings.TrimPrefix(target, "G")) } _, err := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID). SetAtStationNo(atStation). SetFlowTransitMW(0).SetFlowTransitTarget("").ClearFlowTransitAt().Save(ctx) if err == nil { s.ctx.EventLog.Write(ctx, "workpiece.flow.arrive", wp.OrderNo, operator, "workpiece", wp.Sn, fmt.Sprintf("在途到位确认:MW%d 读到 0,托盘已到 %s,台账落定", mw, target), map[string]any{"sn": wp.Sn, "mw": mw, "target": target}) s.notifyDashboard() } return err } // alertFlowTransitTimeout 在途超时预警(同 SN 未读去重)。 func (s *Service) alertFlowTransitTimeout(ctx context.Context, wp *ent.Workpiece) { has, err := s.ctx.EntClient.Alert.Query(). Where(alert.RefTypeEQ("flow_transit_timeout"), alert.RefIdEQ(wp.Sn), alert.StatusEQ("UNREAD")).Exist(ctx) if err != nil || has { return } msg := fmt.Sprintf("工件 %s 的在途指令 MW%d 超过 %d 秒仍未读到 0(目标 %s),请检查 PLC 物理动作或到 PLC 管理页强制清零。", wp.Sn, wp.FlowTransitMW, flowTransitTimeoutMs/1000, wp.FlowTransitTarget) _, _ = s.ctx.EntClient.Alert.Create(). SetRuleId(0).SetType("line_cache_full").SetLevel("warning"). SetTarget(wp.FlowTransitTarget).SetTitle(truncateUTF8(msg, 255)).SetContent(truncateUTF8(msg, 500)). SetRefType("flow_transit_timeout").SetRefId(wp.Sn).SetStatus("UNREAD").Save(ctx) }