Files
bj_power/bj_power_mes/internal/logic/plc_monitor.go
T
SunYF 9aaa768e6c feat(mes): AGV挂起动作引擎 + 智能跟车流转 + PLC快照缓存(2026-11-19 主控拍板)
一、AGV 挂起动作引擎(弃显式任务队列、弃并发硬拒)
- 新增 internal/logic/agv_pending.go:待发动作直接挂任务(pending_action + pending_since),
  CONTINUE_LIFT(举升完成→continueTask#1)/ WAIT_DROP_CONFIRM(人工确认放下→continueTask#2)
  / FREE_ROBOT(末组完成→freeRobot);系统动作超 60s 未触发转预警人工重试,绝不自动重发
- Client 新增 ContinueTask(RCS 2.1.2) / FreeRobot(3.1.2),仅点名释放指定车,禁止释放全部
- agv_task 增 pending_action/pending_since 字段,ent 重生成 + db.go 幂等迁移补丁 + migrateonce
- 回调按 B01/B02/C01 模板编排:业务流转到位即自动放行放下、回调自动放车;
  仅人工派车(MANUAL)挂 WAIT_DROP_CONFIRM;新增 /agv/confirm-drop、/agv/pending/retry
- 前端 AgvManual/Agv 确认放下、挂起重试按钮与等待提示联动

二、智能跟车 + 动态目标截断流转引擎
- 新增 internal/logic/flow_engine.go:事件驱动(报工/扫码),读 48 位物理快照,从下游往上游算,
  前方占用则动态截断到最近空闲缓存位;IN_TRANSIT 在途闭锁防重复下发,MW=0 才确认到位落台账;
  主线占用=台账 OR 传感器,工位 G 位只认台账;在途超 5s 落预警
- workpiece 增 flow_transit_mw/target/at 字段,ent 重生成 + 迁移补丁

三、PLC 读取优化与诊断
- 新增 internal/plc/snapshot_cache.go:2s TTL + singleflight + 写失效,合并 SSE/PLC监控/流转引擎
  的重复点位读取;tcp.go 读块重构、localip.go 多网卡、plcdiag 诊断工具、plc_monitor/logging 配套

四、文档与前端
- help.js 重写「工位下发」帮助:明确报工自动驱动流转 vs 下发路线码的定位、缺料/握手/撤回边界
- 案例.md 补充定稿说明;public/index.html 构建指纹更新
2026-11-19 23:08:46 +08:00

342 lines
14 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"
"errors"
"fmt"
"strconv"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/linepoint"
"bj_power_mes/ent/plcsendlog"
"bj_power_mes/ent/workpiece"
"bj_power_mes/internal/plc"
)
// PointBit 单个点位状态(48 位之一)。
type PointBit struct {
Code string `json:"code"` // G1 / C1 / DOCK01 / JBT21
Has bool `json:"has"` // 有托盘=true
}
// BitsGroup 三组点位(工位 / 主线 / 接驳台 + 库房接驳台)。
type BitsGroup struct {
Mock bool `json:"mock"` // 当前 PLC 为模拟模式(未连接真实 PLC,页面显示「模拟数据」标注)
Station []PointBit `json:"station"`
Main []PointBit `json:"main"`
Dock []PointBit `json:"dock"`
Jbt PointBit `json:"jbt"`
}
// MWState 单个 MW 寄存器当前值 + 解析结果。
type MWState struct {
Addr int `json:"addr"`
Value int `json:"value"`
Category string `json:"category"` // A/B/C/D
InTransit bool `json:"inTransit"`
SrcCode string `json:"srcCode,omitempty"`
TgtCode string `json:"tgtCode,omitempty"`
}
// MonitorPreview 手动下发预览(MW 地址 + 写入值 + 源→目标)。
type MonitorPreview struct {
Ok bool `json:"ok"`
MW int `json:"mw"`
Value int `json:"value"`
SrcCode string `json:"srcCode"`
TgtCode string `json:"tgtCode"`
Reason string `json:"reason,omitempty"`
}
// ManualWriteReq 手动下发请求体。
type ManualWriteReq struct {
SrcType string `json:"srcType"` // G / C
Src int `json:"src"`
TgtType string `json:"tgtType"` // G / C
Tgt int `json:"tgt"`
}
// PlcMonitorBits 读取 48 位点位状态并按位置分组(工位/主线/接驳台+库房)。
// 2026-11-17:PLC 断电时 tcp.go 持锁拨号 ctx 打断不了,裸读会挂满 10s 被 go-zero slowcall
// 掐成 503。改走 plcHardCut(2.5s fail-open),超时返回明确错误而非拖垮页面。
func (s *Service) PlcMonitorBits(ctx context.Context) (*BitsGroup, error) {
// 2026-11-19:走 2s TTL + singleflight 缓存,多路监控/看板读取合并为一次真读(写 MW 后自动失效)。
bits, err := plcHardCut(ctx, 2500*time.Millisecond, func(c context.Context) ([]bool, error) {
return s.ctx.PLC.ReadBitsCached(c)
})
if err != nil {
return nil, fmt.Errorf("读取 PLC 点位失败:2.5 秒内未读到数据,PLC 可能断电或网络不通。请确认 PLC 已上电、网线连接正常后再刷新(%v)", err)
}
g := &BitsGroup{Mock: s.ctx.PLC.IsMock()}
for i := 0; i < 12; i++ {
g.Station = append(g.Station, PointBit{Code: "G" + strconv.Itoa(i+1), Has: bitAt(bits, i)})
}
for i := 0; i < 15; i++ {
g.Main = append(g.Main, PointBit{Code: "C" + strconv.Itoa(i+1), Has: bitAt(bits, 12+i)})
}
for i := 0; i < 20; i++ {
g.Dock = append(g.Dock, PointBit{Code: "DOCK" + pad2(i+1), Has: bitAt(bits, 27+i)})
}
g.Jbt = PointBit{Code: "JBT21", Has: bitAt(bits, 47)}
return g, nil
}
func bitAt(bits []bool, i int) bool {
if i >= 0 && i < len(bits) {
return bits[i]
}
return false
}
// PlcMonitorMW 读取 §4.4 路由表全部 MW 地址当前值并解析(非0 即在途指令)。
// 2026-11-19 修正:原逐地址 ReadMW 会产生 2×45 次 S7 事务,在 2.5s 快照预算内
// 读不完(日志实证 MW822 起成片 deadline exceeded),且高频事务是 PLC 主动断链的
// 诱因之一。改为一次 ReadMWBlock 批量读 MW800..MW887(覆盖全部路由地址),
// 与看板 buildPoints 同口径,单事务完成,耗时从 >2.5s 降到 <50ms。
func (s *Service) PlcMonitorMW(ctx context.Context) ([]MWState, error) {
const (
mwStart = 800
mwCount = 88 // MW800..MW887,覆盖 mwRoutes 最大地址 886
)
vals, err := plcHardCut(ctx, 2500*time.Millisecond, func(c context.Context) ([]int, error) {
return s.ctx.PLC.ReadMWBlock(c, mwStart, mwCount)
})
if err != nil {
return nil, err
}
valAt := func(addr int) int {
if i := addr - mwStart; i >= 0 && i < len(vals) {
return vals[i]
}
return 0
}
addrs := plc.AllRouteAddrs()
out := make([]MWState, 0, len(addrs))
for _, addr := range addrs {
val := valAt(addr)
st := MWState{Addr: addr, Value: val, InTransit: val != 0}
if cat, ok := plc.MWCategory(addr); ok {
st.Category = string(cat)
}
if val != 0 {
if srcType, tgtType, src, tgt, ok := plc.ParseMW(addr, val); ok {
st.SrcCode = string(srcType) + strconv.Itoa(src)
st.TgtCode = string(tgtType) + strconv.Itoa(tgt)
}
}
out = append(out, st)
}
return out, nil
}
// PlcMonitorManualWrite 手动下发路径指令:
// 1) 互斥:若存在在途指令(plc_send_log status=SENT),拒绝并提示,不打断自动线;
// 2) 校验组合合法性(§4.4 路由表);
// 3) 写 MW 寄存器;
// 4) 记操作日志(event_log,type=plc_manual_write)。
func (s *Service) PlcMonitorManualWrite(ctx context.Context, req ManualWriteReq, operator string) (*MonitorPreview, error) {
// 1. 互斥:在途指令(工位下发尚未收到完成信号)
inTransit, err := s.ctx.EntClient.PlcSendLog.Query().Where(plcsendlog.Status("SENT")).Exist(ctx)
if err != nil {
return nil, err
}
if inTransit {
return nil, errors.New("存在在途指令(工位下发尚未收到完成信号),手动下发被拒绝,以免打断自动线;可在「工位下发」页撤回或人工完成后重试")
}
// 2. 校验组合
st, stok := plc.ParseSrcType(req.SrcType)
tt, ttok := plc.ParseSrcType(req.TgtType)
if !stok || !ttok {
return nil, errors.New("非法的源/目标类型")
}
mw, value, ok := plc.LookupRoute(st, req.Src, req.Tgt, tt)
if !ok {
return nil, errors.New("非法的源/目标组合(不在 §4.4 路由表内)")
}
// 2.5 多工单缓存策略(2026-11-03 定论,基础设置可配):
// strict=严格隔离——目标主线位置已被工件占用(不论哪张工单)即拒绝写入,禁共位;
// physical=物理优先(默认)——由 PLC 物理决定,MES 不额外限制。
// 2026-11-05 按产线布局说明修正:缓存是主线位置属性——strict 共位校验只对
// cacheable=true 的可缓存位置(C2/C3/C5/C6/C8/C9/C11/C12/C14)生效;
// 停靠位 C1/C4/C7/C10/C13/C15 不可缓存(工件到达即顶升进工位),不做共位校验。
if req.TgtType == "C" && s.CfgStr(ctx, CfgMultiOrderCachePolicy, "physical") == "strict" {
if pt, perr := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.PointNo(req.TgtType + strconv.Itoa(req.Tgt))).First(ctx); perr == nil && pt != nil && pt.Cacheable && pt.Occupied {
return nil, fmt.Errorf("多工单缓存策略=严格隔离:%s 已被工件 %s(工单 %s)占用,禁止共位;可到「基础设置」切换为物理优先,或先清走该工件",
req.TgtType+strconv.Itoa(req.Tgt), pt.CurrentSn, pt.OrderNo)
}
}
// 3. 写 MW
if err := s.ctx.PLC.Get().WriteMW(ctx, mw, value); err != nil {
return nil, err
}
// 4. 记操作日志
srcCode := req.SrcType + strconv.Itoa(req.Src)
tgtCode := req.TgtType + strconv.Itoa(req.Tgt)
s.ctx.EventLog.Write(ctx, "plc_manual_write", "", operator, "plc", srcCode+"->"+tgtCode,
"手动下发路径指令 "+srcCode+" → "+tgtCode+"(MW"+strconv.Itoa(mw)+"="+strconv.Itoa(value)+")",
map[string]any{
"srcType": req.SrcType, "src": req.Src,
"tgtType": req.TgtType, "tgt": req.Tgt,
"mw": mw, "value": value,
})
return &MonitorPreview{Ok: true, MW: mw, Value: value, SrcCode: srcCode, TgtCode: tgtCode}, nil
}
// ---------- 在途指令强制清零(仅 §4.4 路由区 MW=0,不开放任意写) ----------
// ClearInTransitReq 在途指令强制清零请求体:仅允许 §4.4 路由表覆盖的 MW 地址,写 0。
type ClearInTransitReq struct {
Addr int `json:"addr"` // MW 地址(必须是 §4.4 路由表覆盖的 MW)
}
// ClearInTransitResult 清零结果。
type ClearInTransitResult struct {
Addr int `json:"addr"` // 被清零的 MW 地址
Before int `json:"before"` // 清零前的值(非 0 即在途指令)
}
// PlcMonitorClearInTransit 强制清零在途指令:把 §4.4 路由区某 MW 写 0。
// 仅允许路由表覆盖的 MW 地址(MWCategory 命中),越界/控制区/无关寄存器一律拒绝;不开放任意写。
// 记操作日志(event_log,type=plc_in_transit_clear)。
func (s *Service) PlcMonitorClearInTransit(ctx context.Context, req ClearInTransitReq, operator string) (*ClearInTransitResult, error) {
if req.Addr <= 0 {
return nil, errors.New("缺少 MW 地址")
}
// 仅允许 §4.4 路由表覆盖的 MW(防止误清控制区/无关寄存器)
if _, ok := plc.MWCategory(req.Addr); !ok {
return nil, errors.New("MW" + strconv.Itoa(req.Addr) + " 不在 §4.4 路由表覆盖范围内,操作已拒绝")
}
before, err := s.ctx.PLC.Get().ReadMW(ctx, req.Addr)
if err != nil {
return nil, err
}
if err := s.ctx.PLC.Get().WriteMW(ctx, req.Addr, 0); err != nil {
return nil, err
}
// 2026-11-19 智能跟车联动:强制清零 = 该在途指令作废。清掉对应工件的 IN_TRANSIT 标记,
// 使其不再被"在途闭锁"卡死;台账位置不自动改(指令作废后工件实际位置未知,交由人工纠正)。
clearedSNs := make([]string, 0, 2)
if wps, werr := s.ctx.EntClient.Workpiece.Query().Where(workpiece.FlowTransitMWEQ(req.Addr)).All(ctx); werr == nil {
for _, wp := range wps {
_, _ = s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID).
SetFlowTransitMW(0).SetFlowTransitTarget("").ClearFlowTransitAt().Save(ctx)
clearedSNs = append(clearedSNs, wp.Sn)
}
}
obj := "MW" + strconv.Itoa(req.Addr)
desc := "强制清零在途指令:" + obj + " " + strconv.Itoa(before) + " → 0"
if srcType, tgtType, src, tgt, ok := plc.ParseMW(req.Addr, before); ok {
desc += "(" + string(srcType) + strconv.Itoa(src) + " → " + string(tgtType) + strconv.Itoa(tgt) + ")"
}
if len(clearedSNs) > 0 {
desc += ";已解除在途闭锁的工件:" + strings.Join(clearedSNs, ",") + "(台账位置请人工核对)"
}
s.ctx.EventLog.Write(ctx, "plc_in_transit_clear", "", operator, "plc", obj,
desc,
map[string]any{
"object": obj,
"before": before,
"after": 0,
"operator": operator,
"clearedAt": time.Now().Format(time.RFC3339),
})
return &ClearInTransitResult{Addr: req.Addr, Before: before}, nil
}
// ---------- 工件位置纠正(块 E:产线管理页 tab4) ----------
// PositionMismatch 一处「MES 记录有、PLC 实际无」的位置不一致。
type PositionMismatch struct {
WorkpieceID int64 `json:"workpieceId"`
Sn string `json:"sn"`
OrderNo string `json:"orderNo"`
Status string `json:"status"`
AtStationNo int `json:"atStationNo"` // MES 记录的物理位置
CurStationNo int `json:"curStationNo"` // MES 记录的业务位置(最后报工工位)
}
// PositionCheck 工件位置核对结果:PLC 实际点位态 + MES 记录与实际不符的工件列表。
type PositionCheck struct {
Stations []PointBit `json:"stations"` // G1~G12 当前 PLC 点位态
Mismatches []PositionMismatch `json:"mismatches"` // 记录有、实际无(可纠正)
}
// PlcPositionCheck 核对「MES 记录的工件物理位置 vs PLC 实际托盘位」:
// MES 记 atStationNo=n(工件应在工位 n),但 PLC 该工位无托盘 ⇒ 记录过期/错位,列出待纠正。
func (s *Service) PlcPositionCheck(ctx context.Context) (*PositionCheck, error) {
// 2026-11-17:同 PlcMonitorBits,PLC 不可达时硬切,避免 slowcall 503。
bits, err := plcHardCut(ctx, 2500*time.Millisecond, func(c context.Context) ([]bool, error) {
return s.ctx.PLC.Get().ReadBits(c)
})
if err != nil {
return nil, fmt.Errorf("核对工件位置失败:2.5 秒内未读到 PLC 托盘状态,PLC 可能断电或网络不通。请确认 PLC 已上电、网线连接正常后再刷新(%v)", err)
}
stations := make([]PointBit, 0, 12)
for i := 0; i < 12; i++ {
stations = append(stations, PointBit{Code: "G" + strconv.Itoa(i+1), Has: bitAt(bits, i)})
}
// MES 在制工件(未完工):atStationNo>0 表示"记录说在工位 n"
list, err := s.ctx.EntClient.Workpiece.Query().
Where(workpiece.AtStationNoGT(0), workpiece.StatusNEQ("DONE")).
Order(ent.Desc(workpiece.FieldID)).Limit(200).All(ctx)
if err != nil {
return nil, err
}
mismatches := make([]PositionMismatch, 0)
for _, wp := range list {
n := wp.AtStationNo
if n < 1 || n > 12 {
continue
}
if bitAt(bits, n-1) {
continue // PLC 也说有件:一致
}
mismatches = append(mismatches, PositionMismatch{
WorkpieceID: int64(wp.ID),
Sn: wp.Sn,
OrderNo: wp.OrderNo,
Status: wp.Status,
AtStationNo: n,
CurStationNo: wp.CurrentStationNo,
})
}
return &PositionCheck{Stations: stations, Mismatches: mismatches}, nil
}
// CorrectPositionReq 工件位置纠正请求体。
type CorrectPositionReq struct {
WorkpieceID int64 `json:"workpieceId"`
} // PlcPositionCorrect 纠正工件位置:把"记录在工位、实际 PLC 无托盘"的工件清为不在工位(atStationNo=0)。
// 记操作日志(event_log,type=plc_position_correct),含工件 SN、纠正前/后位置、操作人。
func (s *Service) PlcPositionCorrect(ctx context.Context, req CorrectPositionReq, operator string) error {
if req.WorkpieceID <= 0 {
return errors.New("缺少工件 ID")
}
wp, err := s.ctx.EntClient.Workpiece.Get(ctx, int(req.WorkpieceID))
if err != nil {
return errors.New("工件不存在或已删除")
}
before := wp.AtStationNo
if before <= 0 {
return errors.New("该工件当前未记录工位位置,无需纠正")
}
if _, err := s.ctx.EntClient.Workpiece.UpdateOneID(int(req.WorkpieceID)).
SetAtStationNo(0).Save(ctx); err != nil {
return err
}
obj := "工件 " + wp.Sn
s.ctx.EventLog.Write(ctx, "plc_position_correct", wp.OrderNo, operator, "workpiece", wp.Sn,
"纠正工件位置:"+wp.Sn+" 工位 "+strconv.Itoa(before)+" → 不在工位(PLC 该工位无托盘,记录已过期)",
map[string]any{
"object": obj,
"sn": wp.Sn,
"before": before,
"after": 0,
"operator": operator,
})
return nil
}