Files
bj_power/bj_power_mes/internal/logic/plc_mismatch.go
T

246 lines
10 KiB
Go
Raw Normal View History

package logic
import (
"context"
"errors"
"fmt"
"log"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/eventlog"
"bj_power_mes/ent/plcsendlog"
"bj_power_mes/ent/station"
"bj_power_mes/ent/workpiece"
)
// ============ PLC↔MES 对账(#8 P1 定稿,mock 通道) ============
//
// 前提:MES 需读 PLC 位信号(工位有无托盘)。现有代码无真读能力 → 基于现有 Client 抽象
// + mock 落地检测,不实现真读(真实 S7 寄存器读取待 PLC 点位表,与「路径指令下发」同一阻塞项)。
//
// 对账范围(PLC 地址 → 工位号映射,已按 产线布局说明.md §4.1 最终版点位表确认):
// G1~G10 → 工位 1~10(M895.0~M896.1)
// C15 → 工位 15 (M898.2,C 系列缓存位)
// 不含主线缓存位、不含接驳台,共 11 位。
// 注:G11/G12(M896.2/M896.3)已有独立信号,但本轮无终端处置能力,不纳入对账范围(见 mismatchStations)。
//
// 对账规则(PLC 说有位、MES 说无工件 ⇒ mismatch):
// 工位 x 的 PLC 托盘位 = 1
// 且 无工件满足 at_station = x 且 status ∈ {ONLINE, PROCESSING}
// 且 工位 x 非 DISABLED
// 且 不在「工序码下发后 15 秒」宽限窗口
// ⇒ 报 plc_mes_mismatch
//
// 触发点(事件驱动,禁止定时轮询):
// T2 终端开始作业 / T3 扫 SN / T5 建档提交 → 弹终端(单工位,仅 event_log)
// T4 报工提交 → 阻断报工(单工位,仅 event_log)
// T6 PLC 通讯恢复 / T7 管理员手动核对 → 落预警中心(全量 11 位,event_log + alert)
// T1 路径指令握手后 → 标记不做(握手后 15 秒宽限窗口已覆盖,无需额外标记)
//
// 已知局限(同步写入帮助文档):MES 不知工件流转,G5→G7 途中会误报 G7;
// PLC 路径指令下发做完后该误报消失。
var mismatchStations = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15}
// PlcMesMismatch PLC↔MES 对账命中项
type PlcMesMismatch struct {
StationNo int `json:"stationNo"` // 命中工位号
PlcBit int `json:"plcBit"` // PLC 托盘位读值(恒为 1)
Detail string `json:"detail"` // 中文说明
}
// mismatchOptions 终端两选项(契约,终端侧执行;MES 仅透出枚举):
// new_workpiece=新件建档 / bind_known=绑定已知件。
// (report_exception/ignore 已按用户裁定删除:两项即可覆盖全部不一致,且都能强制闭环。)
var mismatchOptions = []string{"new_workpiece", "bind_known"}
// MismatchOptions 返回终端四选项枚举(供 handler 透出契约)
func MismatchOptions() []string {
return mismatchOptions
}
// DetectStationMismatch 单工位对账检测(纯函数,无副作用:不写日志/预警)。
// 返回 nil 表示未命中(含 PLC 位=0、工位 DISABLED、处于宽限窗口、MES 已知有在制工件等情况)。
func (s *Service) DetectStationMismatch(ctx context.Context, stationNo int) (*PlcMesMismatch, error) {
if stationNo <= 0 {
return nil, errors.New("工位号无效")
}
// 0) 管理员 override 静默期(30 分钟):该工位近期有 supervisor_override 记录则不报
overridden, err := s.stationMismatchOverridden(ctx, stationNo)
if err != nil {
return nil, err
}
if overridden {
return nil, nil
}
// 1) 读 PLC 工位托盘位(mock 通道;真实 S7 待点位表)
has, err := s.ctx.PLC.QueryStationPallet(ctx, stationNo)
if err != nil {
return nil, err
}
if !has {
fmt.Printf("[DBG] early-return: PLC 位=0,不命中\n")
return nil, nil // PLC 说无件,不构成 mismatch
}
// 2) 工位 DISABLED 跳过(不比对禁用工位)
st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(stationNo)).First(ctx)
if err != nil {
if ent.IsNotFound(err) {
return nil, nil // 工位不存在:无法判定,按不命中处理,避免误报未知工位
}
return nil, err
}
if st.Status == "DISABLED" {
fmt.Printf("[DBG] early-return: 工位 %d 禁用,不命中\n", stationNo)
return nil, nil
}
// 3) 宽限窗口:工序码下发后 15 秒内不报(PLC 握手未完成属正常瞬态,T1 握手后即覆盖此窗口)
inGrace, err := s.inMismatchGrace(ctx, stationNo)
if err != nil {
return nil, err
}
if inGrace {
return nil, nil
}
// 4) MES 侧:是否存在 at_station=x 且 status ∈ {ONLINE, PROCESSING} 的工件
cnt, err := s.ctx.EntClient.Workpiece.Query().
Where(
workpiece.AtStationNo(stationNo),
workpiece.StatusIn("ONLINE", "PROCESSING"),
).Count(ctx)
if err != nil {
return nil, err
}
if cnt > 0 {
fmt.Printf("[DBG] early-return: 工位 %d MES 有 %d 个在制工件,不命中\n", stationNo, cnt)
return nil, nil // MES 已知该工位有在制工件,不构成 mismatch
}
// [DEBUG]
// 命中 mismatch:PLC 说有位、MES 说无工件
return &PlcMesMismatch{
StationNo: stationNo,
PlcBit: 1,
Detail: fmt.Sprintf(
"工位%d 检测到 PLC 托盘位有件,但 MES 中该工位无在制工件(ONLINE/PROCESSING),PLC 与 MES 状态不一致",
stationNo),
}, nil
}
// inMismatchGrace 判断工位是否处于「工序码下发后 15 秒」宽限窗口
func (s *Service) inMismatchGrace(ctx context.Context, stationNo int) (bool, error) {
since := time.Now().Add(-15 * time.Second)
n, err := s.ctx.EntClient.PlcSendLog.Query().
Where(
plcsendlog.StationNo(stationNo),
plcsendlog.Status("SENT"),
plcsendlog.SendTimeGTE(since),
).Count(ctx)
if err != nil {
return false, err
}
return n > 0, nil
}
// DetectAllMismatch 全量 11 位对账检测(纯函数)
func (s *Service) DetectAllMismatch(ctx context.Context) ([]PlcMesMismatch, error) {
out := make([]PlcMesMismatch, 0, len(mismatchStations))
for _, no := range mismatchStations {
m, err := s.DetectStationMismatch(ctx, no)
if err != nil {
return nil, err
}
if m != nil {
out = append(out, *m)
}
}
return out, nil
}
// RecordPlcMesMismatch 对账命中落库:写 event_log(plc_mes_mismatch);
// 系统触发(T6 PLC 通讯恢复 / T7 管理员手动核对)额外落预警中心 alert。
// trigger 取值:terminal(T2/T3/T4/T5 终端触发,仅 event_log)、plc_recover(T6)、manual(T7)。
func (s *Service) RecordPlcMesMismatch(ctx context.Context, m *PlcMesMismatch, trigger, orderNo, operator string) {
s.ctx.EventLog.Write(ctx, "plc_mes_mismatch", orderNo, operator, "station",
fmt.Sprintf("%d", m.StationNo), m.Detail,
map[string]any{
"stationNo": m.StationNo,
"plcBit": m.PlcBit,
"trigger": trigger,
"options": mismatchOptions,
})
// 系统触发(T6/T8/T7)落预警中心;失败必须显式记日志,绝不静默吞错
// (历史缺陷:title 按 rune 截断超字节限致此处恒失败且无痕,T6/T7 预警从未落库)
if trigger == "plc_recover" || trigger == "boot" || trigger == "manual" {
if aerr := s.CreateAlert(ctx, "plc_mes_mismatch", "警告",
fmt.Sprintf("工位%d", m.StationNo), m.Detail); aerr != nil {
log.Printf("[plc-mismatch] 落预警中心失败 stationNo=%d trigger=%s err=%v", m.StationNo, trigger, aerr)
}
}
s.notifyDashboard()
}
// detectAndRecord 检测并对账命中落库(终端触发,仅 event_log),返回命中项与错误。
// 供 T2/T3/T4/T5 在各自业务动作后/前调用,统一收口 event_log 写入。
func (s *Service) detectAndRecord(ctx context.Context, stationNo int, trigger, orderNo, operator string) (*PlcMesMismatch, error) {
if stationNo <= 0 {
return nil, nil
}
m, err := s.DetectStationMismatch(ctx, stationNo)
if err != nil || m == nil {
return m, err
}
s.RecordPlcMesMismatch(ctx, m, trigger, orderNo, operator)
return m, nil
}
// CheckStationMismatch 终端触发对账(T2/T3/T4/T5 单工位):检测 + 落 event_log,返回命中项。
// trigger:terminal(T2/T3/T5)/ report(T4 报工阻断)。
func (s *Service) CheckStationMismatch(ctx context.Context, stationNo int, trigger, orderNo, operator string) (*PlcMesMismatch, error) {
return s.detectAndRecord(ctx, stationNo, trigger, orderNo, operator)
}
// CheckAllMismatch 系统触发全量对账(T6 PLC 通讯恢复 / T7 管理员手动核对):
// 检测 11 位 + 逐条落 event_log + 预警中心 alert,返回全部命中项。
func (s *Service) CheckAllMismatch(ctx context.Context, trigger, operator string) ([]PlcMesMismatch, error) {
list, err := s.DetectAllMismatch(ctx)
if err != nil {
return nil, err
}
for i := range list {
s.RecordPlcMesMismatch(ctx, &list[i], trigger, "", operator)
}
return list, nil
}
// stationMismatchOverridden 判定工位是否在 supervisor_override 静默期内(近 30 分钟)。
// 复用 event_log(不建独立表):eventType=plc_mes_mismatch_closed、entityType=station、
// entityId=工位号,createdAt 在近 30 分钟内有记录即视为静默(override 解除该工位对账告警)。
func (s *Service) stationMismatchOverridden(ctx context.Context, stationNo int) (bool, error) {
since := time.Now().Add(-30 * time.Minute)
n, err := s.ctx.EntClient.EventLog.Query().
Where(
eventlog.EventType("plc_mes_mismatch_closed"),
eventlog.EntityType("station"),
eventlog.EntityId(fmt.Sprintf("%d", stationNo)),
eventlog.CreatedAtGTE(since),
).Count(ctx)
if err != nil {
return false, err
}
return n > 0, nil
}
// ResolveMismatchOverride 管理员 override:写 event_log(plc_mes_mismatch_closed, trigger=supervisor_override);
// 静默期内该工位检测不命中(stationMismatchOverridden)。不建工件、不落预警。
// 用于误报或人工处置后解除该工位的对账阻断(与「操作工自行忽略」严格区分:需管理员权限 + 审计)。
func (s *Service) ResolveMismatchOverride(ctx context.Context, stationNo int, reason, operator string) error {
if stationNo <= 0 {
return errors.New("工位号无效")
}
s.ctx.EventLog.Write(ctx, "plc_mes_mismatch_closed", "", operator, "station",
fmt.Sprintf("%d", stationNo),
fmt.Sprintf("工位%d PLC↔MES 对账由管理员 override 关闭:%s", stationNo, reason),
map[string]any{"stationNo": stationNo, "reason": reason, "trigger": "supervisor_override"})
return nil
}