Files
bj_power/bj_power_mes/internal/logic/dashboard.go
T
SunYF 42bcf395d2 feat: AGV三段链安全机制、补料/损耗/下班闭环、接驳台左右互换
AGV 调度:
- 任务重构为 GO_LOAD/TRANSPORT/EMPTY_RETURN/FREE 三段链,到位即停(ARRIVED)需人工确认装卸
- 自由调度单点步进,每段强制弹"请确保路径畅通无杂物";托盘回收独立工作台
- 接驳台 PLC 传感器检测到托盘即自动卸货放行,传感器故障由人工按钮兜底(无轮询)
- 车辆状态只读展示(海康3.1.7 queryAgvStatus),调度仍由 RCS 负责

物料闭环:
- 补料管理(SHORTAGE):工位申请 + 主管审批调增叫料池额度,与借料/差异补发三轨并行
- 损耗台账(loss_ledger):退料实际 < 理论必填原因、后审核,工单不记损耗
- 退料强制指定左/右接驳台,WMS 库管可代工位退料

下班闭环:
- 工位终端自检接驳台剩余物料后下班;库管收货 + 托盘拉走后事件驱动自动结班
- 退出登录未下班仅作安全提示(不强制拦截、不新增责任审批)

接驳台左右按操作员朝向建模(dock.side 字段),废除"奇左偶右"隐式约定;
看板标签 / seed / 迁移补丁 / 布局文档统一为中文左/右。

产线布局说明:C1 前线头 AGV 点、C15 后线尾 AGV 点、外部 O1/O2/O3 散点,
清理修订痕迹为最终态描述。
2026-11-03 18:29:31 +08:00

1008 lines
31 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"
"sort"
"strconv"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/dailyplan"
"bj_power_mes/ent/materialrequest"
"bj_power_mes/ent/plcsendlog"
"bj_power_mes/ent/station"
"bj_power_mes/ent/stationstate"
"bj_power_mes/ent/torquerecord"
"bj_power_mes/ent/workorder"
"bj_power_mes/ent/workpiece"
"bj_power_mes/ent/workpieceprocess"
"bj_power_mes/internal/plc"
)
const dashboardTTL = 60 // 秒,看板缓存
// 工位活动判定窗口:窗口内有工序实绩视为「运行中」,否则为空闲。
// 旧实现用历史累计 done>0 判定,导致工位永远显示「运行中」,永不离线。
const stationActiveWindow = 5 * time.Minute
// ============================================================
// 主入口:看板全量快照
// ============================================================
// DashboardSnapshot 一次返回全部看板数据。
// 各子模块单独容错:某块查询失败只降级该块,不影响整屏(看板是展示系统,宁可缺一块也不要白屏)。
func (s *Service) DashboardSnapshot(ctx context.Context) (*DashboardSnapshot, error) {
return cachedTyped(ctx, s, "dashboard:snapshot", dashboardTTL, func() (*DashboardSnapshot, error) {
now := time.Now()
today := dayStart(now)
snap := &DashboardSnapshot{UpdatedAt: fmtDashboardTime(now)}
snap.Production = s.buildProduction(ctx, today)
snap.Quality = s.buildQuality(ctx, today)
snap.Trace = s.buildTrace(ctx)
snap.Warehouse = s.buildWarehouse(ctx)
snap.Equipment = s.buildEquipment(ctx, today, false)
snap.VirtualEquipment = s.buildEquipment(ctx, today, true) // 虚拟工位(OFFLINE,不连PLC)单独下发
snap.Agv = s.buildAgv(ctx)
snap.Performance = s.buildPerformance(ctx, today)
snap.Alarms = s.buildAlarms(ctx, today)
snap.Trends = s.buildTrends(ctx)
snap.Events = s.buildEvents(ctx)
s.CheckBackupOverdueAlert(ctx) // 备份超期→预警中心(惰性检查,天级节流,无定时器)
return snap, nil
})
}
// DashboardMaterialQuery 看板物料追溯查询:直接转发 WMS 物料档案 + 库存(C7)。
// WMS 不可达时返回 available=false,看板前端降级提示。
func (s *Service) DashboardMaterialQuery(ctx context.Context, code, batch string) (map[string]any, error) {
if s.ctx.Wms == nil {
return map[string]any{"available": false, "found": false, "material": nil, "inventory": []map[string]any{}}, nil
}
res, err := s.ctx.Wms.MaterialQuery(ctx, code, batch)
if err != nil {
return nil, err
}
res["available"] = true
return res, nil
}
// ============================================================
// 屏1/屏2:生产统计
// ============================================================
func (s *Service) buildProduction(ctx context.Context, today time.Time) ProductionStats {
out := ProductionStats{}
tomorrow := today.Add(24 * time.Hour)
// 当日完工产量:以 workpiece.doneAt 落在本日为准
if n, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.DoneAtGTE(today), workpiece.DoneAtLT(tomorrow)).Count(ctx); err == nil {
out.OutputToday = n
}
// 当日计划产量:日排产表当日 planQty 合计
out.TargetToday = s.sumDailyPlanQty(ctx, today.Format("2006-01-02"))
out.AchieveRate = safeRate(float64(out.OutputToday), float64(out.TargetToday))
// 在制:已进线未完工
if n, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.DoneAtIsNil()).Count(ctx); err == nil {
out.InLine = n
}
// 当日工序实绩合格率(一次合格率口径:工序判定而非拧紧单次)
if steps, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtGTE(today), workpieceprocess.EndedAtLT(tomorrow)).
All(ctx); err == nil {
for _, st := range steps {
if strings.EqualFold(st.Result, "NG") {
out.QualityNg++
} else {
out.QualityOk++
}
}
}
out.QualifiedRate = safeRate(float64(out.QualityOk), float64(out.QualityOk+out.QualityNg))
// 当日拧紧总次数
if n, err := s.ctx.EntClient.TorqueRecord.Query().
Where(torquerecord.TimeGTE(today), torquerecord.TimeLT(tomorrow)).Count(ctx); err == nil {
out.TorqueTotal = n
}
// 实际生产节拍:相邻完工时间间隔均值(分钟)。口径可调(见 buildCycleTime)。
out.CycleTimeMin = s.buildCycleTime(ctx)
out.WorkOrders = s.buildWorkOrderProgress(ctx, today)
if len(out.WorkOrders) > 0 {
cur := out.WorkOrders[0]
out.CurrentOrder = &cur
}
// 工位状态汇总由 equipment 填充(避免重复查询),此处先占位
return out
}
func (s *Service) buildWorkOrderProgress(ctx context.Context, today time.Time) []WorkOrderProgress {
wos, err := s.ctx.EntClient.WorkOrder.Query().
Order(ent.Desc(workorder.FieldID)).Limit(20).All(ctx)
if err != nil {
return []WorkOrderProgress{}
}
date := today.Format("2006-01-02")
list := make([]WorkOrderProgress, 0, len(wos))
for _, w := range wos {
item := WorkOrderProgress{
OrderNo: w.WorkOrderNo,
ProductName: w.ProductName,
TotalQty: w.Quantity,
DoneQty: w.FinishedNum,
NgQty: w.FailNum,
Progress: safeRate(float64(w.FinishedNum), float64(w.Quantity)),
Status: w.Status,
PlanStart: fmtDashboardTime(orZero(w.PlanStart)),
PlanEnd: fmtDashboardTime(orZero(w.PlanEnd)),
DailyPlanQty: s.sumDailyPlanQtyByOrder(ctx, date, w.WorkOrderNo),
DailyDoneQty: s.countWorkpieceDoneByOrder(ctx, today, w.WorkOrderNo),
}
// 多工单混生产:每单显示自己的工艺组合路线(唯一路线源头=本工单 flow_combination),不再共用单一在产工单路线
if items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, w); len(items) > 0 {
item.CurrentProcess = "工艺组合 " + RouteStationsStrOfWO(items)
} else {
item.CurrentProcess = "工艺组合 未配置"
}
list = append(list, item)
}
// 进行中的工单排前面,同状态按 ID 倒序
sort.SliceStable(list, func(i, j int) bool {
return rankOrderStatus(list[i].Status) < rankOrderStatus(list[j].Status)
})
return list
}
// buildCycleTime 实际生产节拍:最近 N 条完工工件相邻 DoneAt 间隔的均值(分钟)。
// 口径:节拍 = 相邻完工时间间隔均值(现场可按需替换为理论节拍/设计节拍)。
// 样本不足(<2 条有效间隔)时返回 0,前端显示「—」。
func (s *Service) buildCycleTime(ctx context.Context) float64 {
recent, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.DoneAtNotNil()).
Order(ent.Desc(workpiece.FieldDoneAt)).Limit(30).All(ctx)
if err != nil || len(recent) < 2 {
return 0
}
var sum float64
cnt := 0
for i := 0; i < len(recent)-1; i++ {
if recent[i].DoneAt == nil || recent[i+1].DoneAt == nil {
continue
}
gap := recent[i].DoneAt.Sub(*recent[i+1].DoneAt).Minutes()
if gap <= 0 {
continue
}
sum += gap
cnt++
}
if cnt == 0 {
return 0
}
return sum / float64(cnt)
}
// ============================================================
// 屏3:质量分析
// ============================================================
func (s *Service) buildQuality(ctx context.Context, today time.Time) QualityStats {
out := QualityStats{OkRate: 0}
tomorrow := today.Add(24 * time.Hour)
// 近 200 条拧紧记录:用于绘制扭矩分布散点 + 计算统计量
recs, err := s.ctx.EntClient.TorqueRecord.Query().
Where(torquerecord.TimeGTE(today), torquerecord.TimeLT(tomorrow)).
Order(ent.Asc(torquerecord.FieldTime)).Limit(200).All(ctx)
if err != nil || len(recs) == 0 {
out.TorqueScatter = []TorquePoint{}
out.NgByStation = []RankItem{}
out.NgByOperator = []RankItem{}
out.DailyRate = s.buildDailyOkRate(ctx, 30)
return out
}
stat := TorqueStat{Count: len(recs), MinStrain: recs[0].Strain, MaxStrain: recs[0].Strain}
sum := 0.0
scatter := make([]TorquePoint, 0, len(recs))
ngByStation := map[string]int{}
ngByOperator := map[string]int{}
for i, r := range recs {
if strings.EqualFold(r.Result, "NG") {
stat.NgCount++
ngByStation[r.StationNo]++
ngByOperator[r.Operator]++
} else {
stat.OkCount++
}
sum += r.Strain
if r.Strain < stat.MinStrain {
stat.MinStrain = r.Strain
}
if r.Strain > stat.MaxStrain {
stat.MaxStrain = r.Strain
}
scatter = append(scatter, TorquePoint{Seq: i + 1, Strain: r.Strain, Result: r.Result})
}
stat.AvgStrain = sum / float64(len(recs))
// 规格上下限取自工艺步骤指标(step_criterion),取不到时回退为 0(前端不画控制线)
if lo, hi, target, unit, ok := s.loadTorqueCriterion(ctx); ok {
stat.LowerLimit = lo
stat.UpperLimit = hi
stat.Target = target
stat.Unit = unit
}
out.Torque = stat
out.OkRate = safeRate(float64(stat.OkCount), float64(stat.Count))
out.TorqueScatter = scatter
out.NgByStation = rankFromMap(ngByStation, "工位")
out.NgByOperator = rankFromMap(ngByOperator, "")
out.DailyRate = s.buildDailyOkRate(ctx, 30)
return out
}
// buildDailyOkRate 近 n 日工序一次合格率(供合格率走势图)
func (s *Service) buildDailyOkRate(ctx context.Context, days int) []TrendPoint {
now := time.Now()
points := make([]TrendPoint, 0, days)
for i := days - 1; i >= 0; i-- {
d := dayStart(now.AddDate(0, 0, -i))
next := d.Add(24 * time.Hour)
ok, ng := 0, 0
if steps, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtGTE(d), workpieceprocess.EndedAtLT(next)).All(ctx); err == nil {
for _, st := range steps {
if strings.EqualFold(st.Result, "NG") {
ng++
} else {
ok++
}
}
}
points = append(points, TrendPoint{
Time: d.Format("01-02"),
Output: ok,
QualifiedRate: safeRate(float64(ok), float64(ok+ng)),
})
}
return points
}
// ============================================================
// 屏4:责任追溯
// ============================================================
// buildTrace 返回最近完工工件(含完整工序时间线),供大屏自动轮播
func (s *Service) buildTrace(ctx context.Context) TraceStats {
wps, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.DoneAtNotNil()).
Order(ent.Desc(workpiece.FieldDoneAt)).Limit(10).All(ctx)
if err != nil {
return TraceStats{Recent: []TraceItem{}}
}
items := make([]TraceItem, 0, len(wps))
for _, w := range wps {
item := TraceItem{
Sn: w.Sn,
OrderNo: w.OrderNo,
Status: w.Status,
OnlineAt: fmtDashboardTime(orZero(w.OnlineAt)),
DoneAt: fmtDashboardTime(orZero(w.DoneAt)),
}
if w.DoneAt != nil && w.OnlineAt != nil {
item.DurationMin = w.DoneAt.Sub(*w.OnlineAt).Minutes()
}
item.Steps = s.loadTraceSteps(ctx, w.Sn)
item.StepCount = len(item.Steps)
for _, st := range item.Steps {
if strings.EqualFold(st.Result, "NG") {
item.NgCount++
} else {
item.OkCount++
}
}
items = append(items, item)
}
return TraceStats{Recent: items}
}
// loadTraceSteps 单工件的工序时间线:工序 / 工位 / 操作人 / 时间 / 判定 / 扭矩
func (s *Service) loadTraceSteps(ctx context.Context, sn string) []TraceStep {
steps, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.SnEQ(sn)).
Order(ent.Asc(workpieceprocess.FieldID)).All(ctx)
if err != nil {
return []TraceStep{}
}
// 该工件的拧紧数据:按工位聚合,用于展示每道工序的实际扭矩
tq, _ := s.ctx.EntClient.TorqueRecord.Query().
Where(torquerecord.SnEQ(sn)).All(ctx)
type agg struct {
count, ng int
sum float64
}
byStation := map[string]*agg{}
for _, t := range tq {
a, ok := byStation[t.StationNo]
if !ok {
a = &agg{}
byStation[t.StationNo] = a
}
a.count++
a.sum += t.Strain
if strings.EqualFold(t.Result, "NG") {
a.ng++
}
}
out := make([]TraceStep, 0, len(steps))
for _, st := range steps {
ts := TraceStep{
FlowId: st.FlowId,
ProcessName: st.ProcessName,
StationNo: atoiSafe(st.StationNo),
Operator: st.Operator,
Result: st.Result,
StartedAt: fmtDashboardTime(orZero(st.StartedAt)),
EndedAt: fmtDashboardTime(orZero(st.EndedAt)),
}
if a, ok := byStation[st.StationNo]; ok && a.count > 0 {
ts.TorqueCount = a.count
ts.TorqueNg = a.ng
ts.AvgStrain = a.sum / float64(a.count)
}
out = append(out, ts)
}
return out
}
// DashboardTrace 按需查询单个工件的追溯详情(供看板下钻,不进全量快照)
func (s *Service) DashboardTrace(ctx context.Context, sn string) (*TraceItem, error) {
w, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.SnEQ(sn)).Only(ctx)
if err != nil {
return nil, err
}
item := &TraceItem{
Sn: w.Sn,
OrderNo: w.OrderNo,
Status: w.Status,
OnlineAt: fmtDashboardTime(orZero(w.OnlineAt)),
DoneAt: fmtDashboardTime(orZero(w.DoneAt)),
Steps: s.loadTraceSteps(ctx, w.Sn),
}
item.StepCount = len(item.Steps)
for _, st := range item.Steps {
if strings.EqualFold(st.Result, "NG") {
item.NgCount++
} else {
item.OkCount++
}
}
return item, nil
}
// ============================================================
// 屏5:仓储动态(数据源 WMS 8890)
// ============================================================
func (s *Service) buildWarehouse(ctx context.Context) WarehouseStats {
out := WarehouseStats{Available: false, ZoneDetail: []ZoneStock{}}
if s.ctx.Wms == nil {
return out
}
data, err := s.ctx.Wms.DisplayOverview(ctx)
if err != nil {
return out
}
out.Available = true
out.TotalQty = toInt(data["totalQty"])
out.BatchCount = toInt(data["batchCount"])
out.SnInStock = toInt(data["snInStock"])
out.SemiInStock = toInt(data["semiInStock"])
out.PackageCount = toInt(data["packageCount"])
out.InToday = toInt(data["inToday"])
out.OutToday = toInt(data["outToday"])
out.LockedQty = toInt(data["lockedQty"])
out.MaterialTypes = toInt(data["materialTypes"])
out.LocationUsed = toInt(data["locationUsed"])
out.LocationTotal = toInt(data["locationTotal"])
out.PendingInbound = toInt(data["pendingInbound"])
out.PendingOutbound = toInt(data["pendingOutbound"])
if mv, ok := data["movements"].([]any); ok {
for _, x := range mv {
if m, ok := x.(map[string]any); ok {
out.Movements = append(out.Movements, WmsMovement{
ID: toStr(m["id"]), Time: toStr(m["time"]), Type: toStr(m["type"]),
Material: toStr(m["material"]), Qty: toInt(m["qty"]),
Operator: toStr(m["operator"]), Batch: toStr(m["batch"]),
})
}
}
}
if t, ok := data["time"].(string); ok {
out.UpdatedAt = t
}
if zm, ok := data["zoneDetail"].(map[string]any); ok {
for k, v := range zm {
parts := strings.SplitN(k, "/", 2)
z := ZoneStock{Qty: toInt(v)}
if len(parts) > 0 {
z.Zone = parts[0]
}
if len(parts) > 1 {
z.Quality = parts[1]
}
out.ZoneDetail = append(out.ZoneDetail, z)
}
sort.Slice(out.ZoneDetail, func(i, j int) bool {
return out.ZoneDetail[i].Qty > out.ZoneDetail[j].Qty
})
} else {
out.ZoneDetail = []ZoneStock{}
}
return out
}
// ============================================================
// 屏1:工位实时状态(3D 场景与工位矩阵共用)
// ============================================================
// buildEquipment 工位实时状态聚合。
// offlineOnly=false → 常规工位(连 PLC,前端地图 12 槽位);
// offlineOnly=true → 虚拟工位(station_type=OFFLINE,不连 PLC、仅记录,供地图"虚拟工位"滚动栏展示)。
func (s *Service) buildEquipment(ctx context.Context, today time.Time, offlineOnly bool) []StationState {
typePred := station.StationTypeNEQ("OFFLINE")
if offlineOnly {
typePred = station.StationTypeEQ("OFFLINE")
}
// 工位主数据
stMap := map[int]StationState{}
if sts, err := s.ctx.EntClient.Station.Query().Where(typePred).All(ctx); err == nil {
for _, st := range sts {
stMap[st.StationNo] = StationState{
StationNo: st.StationNo,
Name: stationDisplayName(st.Name, st.StationNo),
Status: "idle",
}
if !strings.EqualFold(st.Status, "ENABLED") {
v := stMap[st.StationNo]
v.Status = "offline"
stMap[st.StationNo] = v
}
}
}
// 工位主数据缺失时兜底:常规工位按 DB 非线下位工位生成;DB 完全空时回退 1~12(虚拟工位无兜底)
if len(stMap) == 0 && !offlineOnly {
if dbStations, e := s.ctx.EntClient.Station.Query().
Where(station.StationTypeNEQ("OFFLINE")).All(ctx); e == nil && len(dbStations) > 0 {
for _, st := range dbStations {
if _, ok := stMap[st.StationNo]; !ok {
stMap[st.StationNo] = StationState{StationNo: st.StationNo, Name: stationDisplayName("", st.StationNo), Status: "idle"}
}
}
} else {
for i := 1; i <= 12; i++ {
if _, ok := stMap[i]; !ok {
stMap[i] = StationState{StationNo: i, Name: stationDisplayName("", i), Status: "idle"}
}
}
}
}
window := time.Now().Add(-stationActiveWindow)
// 活动窗口内的工序实绩:判定 running/alarm,并取当前作业人与工件
if recent, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtGTE(window)).
Order(ent.Desc(workpieceprocess.FieldEndedAt)).All(ctx); err == nil {
for _, r := range recent {
no := atoiSafe(r.StationNo)
v, ok := stMap[no]
if !ok {
continue
}
if v.Status == "offline" {
continue
}
if v.LastActiveAt == "" {
v.LastActiveAt = fmtDashboardTime(orZero(r.EndedAt))
v.CurrentSn = r.Sn
v.CurrentOperator = r.Operator
v.CurrentFlowId = r.FlowId
if v.CurrentProcess == "" {
v.CurrentProcess = r.ProcessName
}
}
if v.Status != "alarm" {
if strings.EqualFold(r.Result, "NG") {
v.Status = "alarm"
} else {
v.Status = "running"
}
}
stMap[no] = v
}
}
// 当天停单(station_state):paused=true 时前端仅以图标提示,不渲染刺眼文字
if pauses, err := s.ctx.EntClient.StationState.Query().
Where(stationstate.Date(today.Format("2006-01-02")), stationstate.Paused(true)).
All(ctx); err == nil {
for _, p := range pauses {
if v, ok := stMap[p.StationNo]; ok {
v.Paused = true
v.PauseReason = p.Reason
stMap[p.StationNo] = v
}
}
}
// 当日累计:每个工位的完成数与 NG 数
if steps, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtGTE(today)).All(ctx); err == nil {
for _, r := range steps {
no := atoiSafe(r.StationNo)
v, ok := stMap[no]
if !ok {
continue
}
v.DoneToday++
if strings.EqualFold(r.Result, "NG") {
v.NgToday++
}
stMap[no] = v
}
}
out := make([]StationState, 0, len(stMap))
for _, v := range stMap {
out = append(out, v)
}
sort.Slice(out, func(i, j int) bool { return out[i].StationNo < out[j].StationNo })
return out
}
// ============================================================
// 3D 场景:AGV
// ============================================================
// buildAgv AGV 状态。
//
// RCS-2000 尚未对接,当前 Source="mock":任务取自真实备料单(material_request.targetDock),
// 即「哪台 AGV 在给哪个工位送什么料」是真实业务事件,仅坐标/电量/进度为模拟值。
// 接入 RCS 后改为调用 /api/robot/controller/robot/query 填充真实坐标即可,前端无需改动。
func (s *Service) buildAgv(ctx context.Context) AgvStats {
out := AgvStats{Source: "mock", Robots: []AgvRobot{}}
reqs, err := s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.TargetDockNEQ("")).
Order(ent.Desc(materialrequest.FieldID)).Limit(2).All(ctx)
if err != nil || len(reqs) == 0 {
// 无任务时给出两台待命 AGV,3D 场景不至于空场
out.Robots = []AgvRobot{
{Code: "AGV-01", Status: "idle", Battery: 88, FromDock: "DOCK21", ToDock: "", Progress: 0},
{Code: "AGV-02", Status: "idle", Battery: 76, FromDock: "DOCK21", ToDock: "", Progress: 0},
}
return out
}
for i, r := range reqs {
carrier := r.MaterialName
if carrier == "" {
carrier = r.MaterialCode
}
out.Robots = append(out.Robots, AgvRobot{
Code: "AGV-" + pad2(i+1),
Status: agvStatusFromRequest(r.Status),
Battery: 90 - i*12,
FromDock: "DOCK21",
ToDock: r.TargetDock,
TaskNo: r.RequestNo,
Carrier: carrier,
// 进度按任务创建时间线性推进,60 秒走完全程;仅用于 3D 动效
Progress: mockAgvProgress(r.CreatedAt),
})
}
return out
}
// agvStatusFromRequest 备料单状态 → AGV 状态(3D 动效据此播放不同动画)
func agvStatusFromRequest(status string) string {
switch strings.ToUpper(status) {
case "LOCKED":
return "loading"
case "DELIVERING":
return "moving"
case "DONE":
return "idle"
default:
return "waiting"
}
}
// ============================================================
// 看板点位态(主线 C1~C15 / 接驳台 G1L..G10R + JBT21 / 在途路径指令)
// ============================================================
// dockCodeToLabel PLC/Dock 表编码(DOCK01..21)→ 布局说明命名(G1L..G10R / JBT21)。
// 2026-11-03 拍板:左右按操作员朝向区分——上排奇数工位 左=L(奇数台);下排偶数工位 2/4/6/8/10
// 操作员面向主线,左手边=地图右(偶数台=L)。与 dock.side 字段、seed、迁移补丁同一口径。
func dockCodeToLabel(code string) string {
c := strings.ToUpper(strings.TrimSpace(code))
if c == "DOCK21" || c == "JBT21" {
return "JBT21"
}
if !strings.HasPrefix(c, "DOCK") {
return c
}
n, err := strconv.Atoi(strings.TrimPrefix(c, "DOCK"))
if err != nil || n < 1 || n > 20 {
return c
}
st := (n + 1) / 2
suffix := "R"
if n%2 == st%2 { // 台序奇偶与工位奇偶同 → 操作员左手边
suffix = "L"
}
return fmt.Sprintf("G%d%s", st, suffix)
}
// buildPoints 看板点位态:主线 15 位 + 接驳台 21 位(PLC 一次位块读)+ 在途路径指令(MW 一次块读)。
// PLC 读取失败只降级本块(返回 Mock=true 空态),不影响整屏快照。
func (s *Service) buildPoints(ctx context.Context) FrontPoints {
out := FrontPoints{Mock: s.ctx.PLC.IsMock(), Main: []FrontPoint{}, Dock: []FrontPoint{}, Transit: []InTransit{}}
bits, err := s.ctx.PLC.ReadBits(ctx)
if err != nil {
return out
}
for i := 0; i < 15; i++ {
out.Main = append(out.Main, FrontPoint{Code: fmt.Sprintf("C%d", i+1), Has: bitAt(bits, 12+i)})
}
for i := 0; i < 20; i++ {
out.Dock = append(out.Dock, FrontPoint{Code: dockCodeToLabel(fmt.Sprintf("DOCK%02d", i+1)), Has: bitAt(bits, 27+i)})
}
out.Dock = append(out.Dock, FrontPoint{Code: "JBT21", Has: bitAt(bits, 47)})
// 在途路径指令:一次批量读 MW800..MW887(44 个路由寄存器),非 0 即在途
if vals, err := s.ctx.PLC.ReadMWBlock(ctx, 800, 88); err == nil {
for _, addr := range plc.AllRouteAddrs() {
idx := addr - 800
if idx < 0 || idx >= len(vals) || vals[idx] == 0 {
continue
}
if srcType, tgtType, src, tgt, ok := plc.ParseMW(addr, vals[idx]); ok {
out.Transit = append(out.Transit, InTransit{
Src: string(srcType) + strconv.Itoa(src),
Tgt: string(tgtType) + strconv.Itoa(tgt),
})
}
}
}
return out
}
// ============================================================
// 屏6:人员绩效
// ============================================================
func (s *Service) buildPerformance(ctx context.Context, today time.Time) []RankItem {
steps, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtGTE(today)).All(ctx)
if err != nil {
return []RankItem{}
}
type agg struct {
count, ok, ng int
stations map[int]bool
}
byOp := map[string]*agg{}
for _, st := range steps {
if st.Operator == "" {
continue
}
a, ok := byOp[st.Operator]
if !ok {
a = &agg{stations: map[int]bool{}}
byOp[st.Operator] = a
}
a.count++
if strings.EqualFold(st.Result, "NG") {
a.ng++
} else {
a.ok++
}
a.stations[atoiSafe(st.StationNo)] = true
}
out := make([]RankItem, 0, len(byOp))
for op, a := range byOp {
item := RankItem{
Key: op,
Label: op,
Count: a.count,
OkCount: a.ok,
NgCount: a.ng,
OkRate: safeRate(float64(a.ok), float64(a.count)),
}
for no := range a.stations {
item.StationNos = append(item.StationNos, no)
}
sort.Ints(item.StationNos)
out = append(out, item)
}
sort.Slice(out, func(i, j int) bool { return out[i].Count > out[j].Count })
return out
}
// ============================================================
// 报警 / 趋势 / 事件流
// ============================================================
func (s *Service) buildAlarms(ctx context.Context, today time.Time) []AlarmItem {
items := []AlarmItem{}
if n, err := s.ctx.EntClient.TorqueRecord.Query().
Where(torquerecord.Result("NG"), torquerecord.TimeGTE(today)).Count(ctx); err == nil && n > 0 {
items = append(items, AlarmItem{
ID: "torque-ng", Level: "critical", Type: "quality",
Target: "拧紧", Message: "当日拧紧 NG " + itoa(n) + " 次", Time: fmtDashboardTime(time.Now()),
Status: "active",
})
}
// 在途未完成下发(2026-11-03 断头路收口):原统计 status=TIMEOUT 但全项目无人写入 TIMEOUT,恒为 0。
// 改统计 SENT(已下发未收到完成信号)——超 1 条即说明产线有指令挂起,需在「工位下发」页撤回或人工完成。
if n, err := s.ctx.EntClient.PlcSendLog.Query().
Where(plcsendlog.Status("SENT")).Count(ctx); err == nil && n > 0 {
items = append(items, AlarmItem{
ID: "plc-intransit", Level: "critical", Type: "equipment",
Target: "PLC", Message: "存在在途未完成的工位下发 " + itoa(n) + " 条,请在「工位下发」页收口", Time: fmtDashboardTime(time.Now()),
Status: "active",
})
}
if len(items) == 0 {
items = []AlarmItem{}
}
return items
}
func (s *Service) buildTrends(ctx context.Context) []TrendPoint {
points := make([]TrendPoint, 0, 7)
for i := 6; i >= 0; i-- {
d := dayStart(time.Now().AddDate(0, 0, -i))
next := d.Add(24 * time.Hour)
done := 0
if n, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.DoneAtGTE(d), workpiece.DoneAtLT(next)).Count(ctx); err == nil {
done = n
}
ok, ng := 0, 0
if steps, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtGTE(d), workpieceprocess.EndedAtLT(next)).All(ctx); err == nil {
for _, st := range steps {
if strings.EqualFold(st.Result, "NG") {
ng++
} else {
ok++
}
}
}
points = append(points, TrendPoint{
Time: d.Format("01-02"),
Output: done,
QualifiedRate: safeRate(float64(ok), float64(ok+ng)),
})
}
return points
}
// buildEvents 底部实时事件跑马灯:取最近 20 条工序实绩
func (s *Service) buildEvents(ctx context.Context) []EventItem {
steps, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtNotNil()).
Order(ent.Desc(workpieceprocess.FieldEndedAt)).Limit(20).All(ctx)
if err != nil {
return []EventItem{}
}
out := make([]EventItem, 0, len(steps))
for _, st := range steps {
level := "info"
if strings.EqualFold(st.Result, "NG") {
level = "error"
}
name := st.ProcessName
if name == "" {
name = "工艺" + itoa(st.FlowId)
}
out = append(out, EventItem{
Time: fmtDateTimeHm(orZero(st.EndedAt)),
Text: "工位" + st.StationNo + " " + st.Operator + " 完成 " + st.Sn + " " + name + " " + st.Result,
Level: level,
})
}
return out
}
// ============================================================
// 辅助
// ============================================================
func dayStart(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
}
func orZero(t *time.Time) time.Time {
if t == nil {
return time.Time{}
}
return *t
}
func fmtDateTimeHm(t time.Time) string {
if t.IsZero() {
return ""
}
return t.Format("15:04")
}
func pad2(n int) string {
if n < 10 {
return "0" + itoa(n)
}
return itoa(n)
}
func atoiSafe(s string) int {
n, _ := strconv.Atoi(strings.TrimSpace(s))
return n
}
func stationDisplayName(name string, no int) string {
if strings.TrimSpace(name) != "" {
return name
}
return "工位" + itoa(no)
}
func toInt(v any) int {
switch x := v.(type) {
case float64:
return int(x)
case int:
return x
case int64:
return int(x)
case string:
n, _ := strconv.Atoi(x)
return n
}
return 0
}
func toStr(v any) string {
if v == nil {
return ""
}
switch x := v.(type) {
case string:
return x
case fmt.Stringer:
return x.String()
default:
return fmt.Sprintf("%v", x)
}
}
// rankFromMap 把 map 排行化,按数量降序;prefix 用于生成展示名(如「工位」)
func rankFromMap(m map[string]int, prefix string) []RankItem {
out := make([]RankItem, 0, len(m))
for k, v := range m {
if k == "" {
continue
}
out = append(out, RankItem{Key: k, Label: prefix + k, Count: v, StationNos: []int{}})
}
sort.Slice(out, func(i, j int) bool { return out[i].Count > out[j].Count })
if len(out) > 10 {
out = out[:10]
}
return out
}
// rankOrderStatus 工单排序权重:进行中优先
func rankOrderStatus(status string) int {
switch strings.ToUpper(status) {
case "IN_PROGRESS":
return 0
case "RELEASED":
return 0 // 存量兼容:旧 RELEASED 等同已开工(IN_PROGRESS)
case "CREATED":
return 2
case "COMPLETED":
return 3
default:
return 4
}
}
// sumDailyPlanQty 当日排产计划总量(看板「目标产量」)
func (s *Service) sumDailyPlanQty(ctx context.Context, date string) int {
plans, err := s.ctx.EntClient.DailyPlan.Query().
Where(dailyplan.PlanDateEQ(date)).All(ctx)
if err != nil {
return 0
}
sum := 0
for _, p := range plans {
sum += p.PlanQty
}
return sum
}
// sumDailyPlanQtyByOrder 某工单当日排产计划量
func (s *Service) sumDailyPlanQtyByOrder(ctx context.Context, date, orderNo string) int {
plans, err := s.ctx.EntClient.DailyPlan.Query().
Where(dailyplan.PlanDateEQ(date), dailyplan.OrderNoEQ(orderNo)).All(ctx)
if err != nil {
return 0
}
sum := 0
for _, p := range plans {
sum += p.PlanQty
}
return sum
}
// countWorkpieceDoneByOrder 某工单当日完工数(日计划达成用)
func (s *Service) countWorkpieceDoneByOrder(ctx context.Context, today time.Time, orderNo string) int {
n, err := s.ctx.EntClient.Workpiece.Query().
Where(
workpiece.OrderNoEQ(orderNo),
workpiece.DoneAtGTE(today),
workpiece.DoneAtLT(today.Add(24*time.Hour)),
).Count(ctx)
if err != nil {
return 0
}
return n
}
// loadTorqueCriterion 取工艺指标中的扭矩规格(上下限/目标值/单位),用于绘制控制图规格线。
// 取不到时返回 ok=false,前端不画控制线(不臆造规格值)。
// 与 evaluateTorqueCriterion 统一口径:取「采集方式=拧紧枪自动(AUTO)步骤 + RANGE 逻辑」的标准,不依赖指标名(如「扭矩」)。
func (s *Service) loadTorqueCriterion(ctx context.Context) (lo, hi, target float64, unit string, ok bool) {
crits, err := s.torqueRangeCriteria(ctx, 0)
if err != nil || len(crits) == 0 {
return 0, 0, 0, "", false
}
c := crits[0]
lo, hi = 0, 0
if c.Min != nil {
lo = *c.Min
}
if c.Max != nil {
hi = *c.Max
}
return lo, hi, c.Target, c.Unit, true
}
// mockAgvProgress 模拟 AGV 任务进度:任务创建后 60 秒线性走完全程。
// 仅用于 3D 动效,接入 RCS 后由真实坐标替换。
func mockAgvProgress(created time.Time) float64 {
elapsed := time.Since(created).Seconds()
if elapsed <= 0 {
return 0
}
p := elapsed / 60
if p > 1 {
return 1
}
return p
}