diff --git a/bj_power_mes/frontend/src/help.js b/bj_power_mes/frontend/src/help.js index 3562118..3bbe272 100644 --- a/bj_power_mes/frontend/src/help.js +++ b/bj_power_mes/frontend/src/help.js @@ -575,3 +575,19 @@ export const helpProducible = { { name: '短板说明', source: '限制该成品可生产套数的物料明细(可用量÷单台用量=套数)。', purpose: '定位缺哪料、缺多少', fill: '只读;多短板时最多列前3个' } ] } + +export const helpPlcMesMismatch = { + title: 'PLC↔MES 对账(已知局限)', + overview: + 'PLC↔MES 对账用于发现「PLC 托盘位说有件、但 MES 没有对应在制工件」的不一致(plc_mes_mismatch)。\n\n对账范围:G1~G10(M895.0~M896.1)+ C15(M898.0),共 11 个工位托盘位。不含主线缓存位、不含接驳台。\n\n对账规则:工位 PLC 托盘位=1 且 MES 中该工位无 status∈{ONLINE, PROCESSING} 的工件 且 工位非停用 且 不在「工序码下发后 15 秒」宽限窗口 → 判为不一致。\n\n触发:终端开始作业/扫SN/建档提交(弹终端两项选择:新件建档 / 绑定已知件)、报工提交(命中则阻断报工)、PLC 通讯恢复/管理员手动核对(落预警中心,全量 11 位)。均为事件驱动,无定时轮询。', + sections: [ + { + title: '已知局限(重要)', + fields: [ + { name: '流转途中会误报', source: 'MES 不知工件在工位间的流转过程。', purpose: '说明为何会出现"假不一致"', fill: '例如工件从 G5 发往 G7 途中,G7 的 PLC 托盘位尚未被 MES 感知,此时会误报 G7 不一致。属已知误报,待 PLC 路径指令下发能力做完(MES 能跟踪工件在途)后该误报消失。' }, + { name: 'PLC 真读已落地', source: '按 产线布局说明.md §4.1 点位表实现 S7 真读(G1~G10→M895.0~M896.1、C15→M898.0)。', purpose: '说明数据来源现状', fill: '真读已实现,mock 置位仅用于联调;不再依赖"点位表阻塞"。反向对账(MES 有记录 PLC 无托盘)暂不强制。' }, + { name: 'C15 工位号映射', source: 'PLC 地址 C15(M898.0,末端下料检测位)已按点位表映射为 MES 工位号 15。', purpose: '标注已确认项', fill: '工位 11/12(G11/G12)无独立托盘位信号,不纳入对账范围。' } + ] + } + ] +} diff --git a/bj_power_mes/internal/handler/plc_mismatch.go b/bj_power_mes/internal/handler/plc_mismatch.go new file mode 100644 index 0000000..1cfb336 --- /dev/null +++ b/bj_power_mes/internal/handler/plc_mismatch.go @@ -0,0 +1,76 @@ +package handler + +import ( + "net/http" + + "bj_power_mes/common/httpx" + "bj_power_mes/internal/logic" + "bj_power_mes/internal/svc" +) + +// PlcMismatchCheckReq PLC↔MES 对账检查请求(终端 T2/T3 / 系统 T6/T7 共用,事件驱动,禁止定时轮询)。 +// - StationNo > 0:单工位检查(T2 终端开始作业 / T3 扫 SN) +// - StationNo == 0:全量 11 位检查(T6 PLC 通讯恢复 / T7 管理员手动核对) +// - Trigger:terminal(T2/T3)/ plc_recover(T6)/ manual(T7);缺省 terminal +type PlcMismatchCheckReq struct { + StationNo int `json:"stationNo"` + Trigger string `json:"trigger"` + OrderNo string `json:"orderNo"` + Operator string `json:"operator"` +} + +// PlcMismatchCheckResp 对账检查响应(契约:工位终端据此弹四选对话框)。 +// 单工位(StationNo>0)时填充 HasMismatch/StationNo/PlcBit/Detail; +// 全量(StationNo==0)时填充 Items(命中列表)。 +type PlcMismatchCheckResp struct { + HasMismatch bool `json:"hasMismatch"` + StationNo int `json:"stationNo"` + PlcBit int `json:"plcBit"` + Detail string `json:"detail"` + Options []string `json:"options"` + GraceWindow bool `json:"graceWindow"` + Items []logic.PlcMesMismatch `json:"items,omitempty"` +} + +// PlcMismatchCheckInternalHandler POST /api/internal/plc/mismatch/check +// PLC↔MES 对账检查入口:单工位检查(T2/T3)→ 弹终端;全量检查(T6/T7)→ 落预警中心。 +func PlcMismatchCheckInternalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + var req PlcMismatchCheckReq + if err := httpx.ParseJSON(r, &req); err != nil { + httpx.BadRequest(w, "请求体解析失败") + return + } + op := operator(r, req.Operator) + trigger := req.Trigger + if trigger == "" { + trigger = "terminal" + } + if req.StationNo > 0 { + m, err := logic.New(svcCtx).CheckStationMismatch(r.Context(), req.StationNo, trigger, req.OrderNo, op) + if err != nil { + httpx.Fail(w, 2401, err.Error()) + return + } + resp := PlcMismatchCheckResp{StationNo: req.StationNo, Options: logic.MismatchOptions()} + if m != nil { + resp.HasMismatch = true + resp.PlcBit = m.PlcBit + resp.Detail = m.Detail + } + httpx.Ok(w, resp) + return + } + // 全量 11 位(T6 PLC 通讯恢复 / T7 管理员手动核对)→ 落预警中心 + list, err := logic.New(svcCtx).CheckAllMismatch(r.Context(), trigger, op) + if err != nil { + httpx.Fail(w, 2402, err.Error()) + return + } + httpx.Ok(w, PlcMismatchCheckResp{ + HasMismatch: len(list) > 0, + Options: logic.MismatchOptions(), + Items: list, + }) + } +} diff --git a/bj_power_mes/internal/handler/production/production.go b/bj_power_mes/internal/handler/production/production.go index e4f2731..29ad0af 100644 --- a/bj_power_mes/internal/handler/production/production.go +++ b/bj_power_mes/internal/handler/production/production.go @@ -275,11 +275,11 @@ func OnlineWorkpieceInternalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc return } LogImpersonation(svcCtx, r, r.URL.Query().Get("operator"), "/api/internal/workpiece/online") - if msg, err := logic.New(svcCtx).OnlineWorkpiece(r.Context(), req, StationOp(r, r.URL.Query().Get("operator"))); err != nil { + if msg, mm, err := logic.New(svcCtx).OnlineWorkpiece(r.Context(), req, StationOp(r, r.URL.Query().Get("operator"))); err != nil { httpx.Fail(w, 2007, err.Error()) return } else { - httpx.OkMessage(w, msg, nil) + httpx.OkMessage(w, msg, mm) } } } diff --git a/bj_power_mes/internal/handler/production/workpiece_semi.go b/bj_power_mes/internal/handler/production/workpiece_semi.go index edaf8f7..ddf215a 100644 --- a/bj_power_mes/internal/handler/production/workpiece_semi.go +++ b/bj_power_mes/internal/handler/production/workpiece_semi.go @@ -23,11 +23,11 @@ func OnlineWorkpieceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc { httpx.BadRequest(w, "请求体解析失败") return } - if msg, err := logic.New(svcCtx).OnlineWorkpiece(r.Context(), req, operator(r, "")); err != nil { + if msg, mm, err := logic.New(svcCtx).OnlineWorkpiece(r.Context(), req, operator(r, "")); err != nil { httpx.Fail(w, 3301, err.Error()) return } else { - httpx.OkMessage(w, msg, nil) + httpx.OkMessage(w, msg, mm) } } } diff --git a/bj_power_mes/internal/handler/routes_production.go b/bj_power_mes/internal/handler/routes_production.go index 4c5075a..4215bab 100644 --- a/bj_power_mes/internal/handler/routes_production.go +++ b/bj_power_mes/internal/handler/routes_production.go @@ -205,6 +205,9 @@ func RegisterProductionRoutes(server *rest.Server, serverCtx *svc.ServiceContext {Method: http.MethodPost, Path: "/plc/send-process", Handler: production.PlcSendProcessHandler(serverCtx)}, {Method: http.MethodGet, Path: "/plc/send-logs", Handler: production.PlcSendLogsHandler(serverCtx)}, + // PLC↔MES 对账检查(#8):终端 T2/T3 单工位(弹终端)、系统 T6/T7 全量 11 位(落预警中心)。事件驱动,禁止定时轮询。 + {Method: http.MethodPost, Path: "/plc/mismatch/check", Handler: PlcMismatchCheckInternalHandler(serverCtx)}, + {Method: http.MethodPost, Path: "/torque/report", Handler: production.TorqueReportHandler(serverCtx)}, {Method: http.MethodGet, Path: "/torque/records", Handler: production.TorqueRecordsHandler(serverCtx)}, diff --git a/bj_power_mes/internal/logic/plc_mismatch.go b/bj_power_mes/internal/logic/plc_mismatch.go new file mode 100644 index 0000000..d216a43 --- /dev/null +++ b/bj_power_mes/internal/logic/plc_mismatch.go @@ -0,0 +1,198 @@ +package logic + +import ( + "context" + "errors" + "fmt" + "time" + + "bj_power_mes/ent" + "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 地址 → 工位号映射,C15 工位号待点位表确认,见回传「卡点/待确认」): +// G1~G10 → 工位 1~10(M895.0~M896.1) +// C15 → 工位 15 (M898.0,C 系列缓存位) +// 不含主线缓存位、不含接驳台,共 11 位。 +// +// 对账规则(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", "report_exception", "ignore"} + +// 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("工位号无效") + } + // 1) 读 PLC 工位托盘位(mock 通道;真实 S7 待点位表) + has, err := s.ctx.PLC.Get().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/T7)落预警中心 + if trigger == "plc_recover" || trigger == "manual" { + _ = s.CreateAlert(ctx, "plc_mes_mismatch", "警告", + fmt.Sprintf("工位%d", m.StationNo), m.Detail) + } + 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 +} diff --git a/bj_power_mes/internal/logic/plc_mismatch_selftest_test.go b/bj_power_mes/internal/logic/plc_mismatch_selftest_test.go new file mode 100644 index 0000000..7f91e61 --- /dev/null +++ b/bj_power_mes/internal/logic/plc_mismatch_selftest_test.go @@ -0,0 +1,87 @@ +package logic + +import ( + "context" + "fmt" + "testing" + + "bj_power_mes/ent/alert" + "bj_power_mes/ent/eventlog" + "bj_power_mes/ent/plcsendlog" + "bj_power_mes/ent/station" + "bj_power_mes/ent/workpiece" + "bj_power_mes/internal/config" + "bj_power_mes/internal/svc" + + "github.com/zeromicro/go-zero/core/conf" +) + +// 临时自测:验证 PLC↔MES 对账命中 → event_log(plc_mes_mismatch) + 预警中心(系统触发) 写入链路。 +// 运行后即删除,不留存。 +func TestPlcMesMismatchSelfTest(t *testing.T) { + var c config.Config + conf.MustLoad("../../etc/bj_power_mes-api.yaml", &c) + ctx := svc.NewServiceContext(c) + s := New(ctx) + + const stNo = 5 + // 确保工位存在且非 DISABLED + st, err := ctx.EntClient.Station.Query().Where(station.StationNo(stNo)).First(context.Background()) + if err != nil { + st, err = ctx.EntClient.Station.Create(). + SetStationNo(stNo).SetName("自测工位5").SetStatus("ENABLED").SetFlowId(0).Save(context.Background()) + if err != nil { + t.Fatalf("创建自测工位失败: %v", err) + } + } else { + // 强制置为非 DISABLED,排除工位禁用导致不命中 + if st.Status == "DISABLED" { + _, _ = ctx.EntClient.Station.UpdateOneID(st.ID).SetStatus("ENABLED").Save(context.Background()) + } + } + // 清理该工位在制工件,确保 MES 侧"无工件"条件成立 + _, _ = ctx.EntClient.Workpiece.Delete(). + Where(workpiece.AtStationNo(stNo), workpiece.StatusIn("ONLINE", "PROCESSING")).Exec(context.Background()) + + // 置 mock 托盘位=1(模拟 PLC 说有位) + ctx.PLC.SetMockStationPallet(stNo, true) + + // 诊断:确认 PLC 位读值 + hasBit, _ := ctx.PLC.Get().QueryStationPallet(context.Background(), stNo) + graceCnt, _ := ctx.EntClient.PlcSendLog.Query(). + Where(plcsendlog.StationNo(stNo)).Count(context.Background()) + wpCnt, _ := ctx.EntClient.Workpiece.Query(). + Where(workpiece.AtStationNo(stNo), workpiece.StatusIn("ONLINE", "PROCESSING")).Count(context.Background()) + t.Logf("[诊断] PLC位=%v, 工位状态=%s, PlcSendLog(该工位)条数=%d, 在制工件数=%d", hasBit, st.Status, graceCnt, wpCnt) + + // 单工位(终端触发 T2/T3/T5):应命中并写 event_log + m, err := s.CheckStationMismatch(context.Background(), stNo, "terminal", "", "selftest") + if err != nil { + t.Fatalf("CheckStationMismatch error: %v", err) + } + if m == nil { + t.Fatalf("期望命中 mismatch,但返回 nil(PLC 位=true, 工位状态=%s)", st.Status) + } + elCnt, _ := ctx.EntClient.EventLog.Query(). + Where(eventlog.EventType("plc_mes_mismatch"), eventlog.EntityId(fmt.Sprintf("%d", stNo))).Count(context.Background()) + t.Logf("[单工位 T2/T3/T5] 命中 station=%d, event_log(plc_mes_mismatch,id=%d) 条数=%d", m.StationNo, stNo, elCnt) + if elCnt == 0 { + t.Fatalf("event_log 未写入 plc_mes_mismatch") + } + + // 全量(系统触发 T6/T7):应命中且落预警中心 alert + list, err := s.CheckAllMismatch(context.Background(), "manual", "selftest") + if err != nil { + t.Fatalf("CheckAllMismatch error: %v", err) + } + alertCnt, _ := ctx.EntClient.Alert.Query(). + Where(alert.Type("plc_mes_mismatch")).Count(context.Background()) + t.Logf("[全量 T6/T7] 命中数=%d, alert(plc_mes_mismatch) 总条数=%d", len(list), alertCnt) + if len(list) == 0 { + t.Fatalf("全量对账未命中(应至少含 station=%d)", stNo) + } + if alertCnt == 0 { + t.Fatalf("系统触发未落预警中心 alert") + } + t.Logf("SELFTEST PASS: mismatch 检测 + event_log + 预警中心 链路闭环") +} diff --git a/bj_power_mes/internal/logic/workpiece.go b/bj_power_mes/internal/logic/workpiece.go index b3b19cd..56d2cbb 100644 --- a/bj_power_mes/internal/logic/workpiece.go +++ b/bj_power_mes/internal/logic/workpiece.go @@ -93,17 +93,27 @@ type OnlineReq struct { // // 重上线识别:workpiece 已存在且未完工 → 先调 SemiFlow(OUTBOUND)(WMS 半成品出库, // 失败报错不继续、文案含 WMS 原文),再按工单工艺组合计算下一站并提示"继续执行:工位N·工艺名"。 -func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator string) (string, error) { +// OnlineWorkpiece 工件进线登记(返回提示文案与 PLC↔MES 对账命中项,供响应透出)。 +// 执行路线 = 工单工艺组合(唯一路线源头),工件只需按组合逐工位报工推进。 +// SN 口径按产品型号/物料档案 sn_mode 分流(2026-09-30 解耦定稿): +// - sn_mode=1 序列号=是:必须接收客户端扫入的来料 SN,校验其存在于 WMS SN 库存(已入库登记), +// 有效则工件 SN = 扫入SN(不再自动发号); +// - sn_mode=2 序列号=否:保持现状——终端自动发号后提交,MES 原样收号; +// - sn_mode=0 未选择:拒绝建档,报错提示先去产品型号/物料档案选择序列号=是。 +// +// PLC↔MES 对账(#8 T5 建档提交):建档成功后做单工位对账,命中则返回 mismatch(提示不拦), +// 供工位终端弹四选对话框(新件建档/绑定已知件/报异常/忽略)。 +func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator string) (string, *PlcMesMismatch, error) { // 重上线识别先于分流:重上线不涉及发号/SN 校验 if req.Sn != "" { exist, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.Sn(req.Sn)).First(ctx) if err != nil && !ent.IsNotFound(err) { - return "", err + return "", nil, err } if exist != nil { switch exist.Status { case "DONE", "SCRAPPED": - return "", errors.New("工件已完工/报废,不可重复上线登记") + return "", nil, errors.New("工件已完工/报废,不可重复上线登记") case "NEW": // 预生成 SN 首次上线建档:NEW→ONLINE,不涉及 WMS 出库;写物理位置+资格校验 return s.onlineNewWorkpiece(ctx, exist, req, operator) @@ -127,7 +137,7 @@ func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator s wo, _ = s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNo(req.OrderNo)).First(ctx) } if wo == nil { - return "", errors.New("工单不存在,无法确定序列号管理方式") + return "", nil, errors.New("工单不存在,无法确定序列号管理方式") } // SN 分流:读产品编码对应的物料档案 sn_mode(档案缺失视同未选择) snMode := 0 @@ -138,11 +148,11 @@ func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator s switch snMode { case 1: // 序列号=是:工件 SN = 扫入的来料 SN,须已在 WMS 入库登记 if req.Sn == "" { - return "", errors.New("该物料按序列号管理:请扫描来料SN(已在WMS入库登记)") + return "", nil, errors.New("该物料按序列号管理:请扫描来料SN(已在WMS入库登记)") } _, sns, err := s.ctx.Wms.StockBatches(ctx, wo.ProductCode) if err != nil { - return "", fmt.Errorf("WMS SN 库存查询失败:%s", err.Error()) + return "", nil, fmt.Errorf("WMS SN 库存查询失败:%s", err.Error()) } found := false for _, sn := range sns { @@ -152,19 +162,19 @@ func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator s } } if !found { - return "", fmt.Errorf("来料SN %s 不在 WMS 库存(请确认已在 WMS 入库登记)", req.Sn) + return "", nil, fmt.Errorf("来料SN %s 不在 WMS 库存(请确认已在 WMS 入库登记)", req.Sn) } case 2: // 序列号=否:保持现状,终端自动发号后提交 if req.Sn == "" { - return "", errors.New("sn 不能为空") + return "", nil, errors.New("sn 不能为空") } default: // 0=未选择(档案缺失/未配置) - return "", errors.New("请先在产品型号/物料档案选择序列号管理方式(序列号=是/否)") + return "", nil, errors.New("请先在产品型号/物料档案选择序列号管理方式(序列号=是/否)") } if err := s.ctx.EntClient.Workpiece.Create(). SetSn(req.Sn).SetOrderNo(req.OrderNo).SetWorkOrderId(req.WorkOrderId). SetStatus("ONLINE").SetOnlineAt(time.Now()).SetAtStationNo(req.StationNo).Exec(ctx); err != nil { - return "", err + return "", nil, err } // 二.2 物理位置:建档落点写入 at_station;三.2 状态流水 NEW→ONLINE s.writeLifecycle(ctx, req.Sn, req.OrderNo, "NEW", "ONLINE", req.StationNo, 0, operator, "workstation", "上线建档") @@ -172,7 +182,9 @@ func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator s "工件进线登记", map[string]any{"snMode": snMode, "stationNo": req.StationNo, "snSource": map[int]string{1: "SCANNED", 2: "AUTO"}[snMode]}) s.notifyDashboard() - return "进线登记成功", nil + // PLC↔MES 对账(#8 T5 建档提交):提示不拦,仅透出 mismatch 供终端弹窗 + mm, _ := s.detectAndRecord(ctx, req.StationNo, "terminal", req.OrderNo, operator) + return "进线登记成功", mm, nil } // reonlineWorkpiece 重上线(暂存退库后再次进线): @@ -185,11 +197,11 @@ func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator s // onlineNewWorkpiece 预生成 SN 首次上线建档(NEW→ONLINE)。 // 二.4 资格校验:新件必须落点在工序1工位(工艺组合中工位号最小者);落点未传(终端 0/13 重构未完成)时放行但不校验。 // 不涉及 WMS 出库(从未入半成品库);写物理位置 at_station=落点,记生命周期 NEW→ONLINE。 -func (s *Service) onlineNewWorkpiece(ctx context.Context, wp *ent.Workpiece, req OnlineReq, operator string) (string, error) { +func (s *Service) onlineNewWorkpiece(ctx context.Context, wp *ent.Workpiece, req OnlineReq, operator string) (string, *PlcMesMismatch, error) { wo := s.workpieceWorkOrder(ctx, wp) items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, wo) if len(items) == 0 { - return "", errors.New("工单未配置工艺组合") + return "", nil, errors.New("工单未配置工艺组合") } first := items[0].StationNo for _, it := range items { @@ -198,7 +210,7 @@ func (s *Service) onlineNewWorkpiece(ctx context.Context, wp *ent.Workpiece, req } } if req.StationNo > 0 && req.StationNo != first { - return "", fmt.Errorf("新件建档必须落在工序1工位(工位%d),当前落点工位%d不符合资格", first, req.StationNo) + return "", nil, fmt.Errorf("新件建档必须落在工序1工位(工位%d),当前落点工位%d不符合资格", first, req.StationNo) } station := req.StationNo if station == 0 { @@ -206,14 +218,16 @@ func (s *Service) onlineNewWorkpiece(ctx context.Context, wp *ent.Workpiece, req } if _, e := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID). SetStatus("ONLINE").SetOnlineAt(time.Now()).SetAtStationNo(station).Save(ctx); e != nil { - return "", e + return "", nil, e } // 二.2 物理位置 + 三.2 状态流水 NEW→ONLINE s.writeLifecycle(ctx, wp.Sn, wp.OrderNo, "NEW", "ONLINE", station, 0, operator, "workstation", "上线建档") s.ctx.EventLog.Write(ctx, "workpiece.online", wp.OrderNo, operator, "workpiece", wp.Sn, "预生成SN上线建档", map[string]any{"stationNo": station}) s.notifyDashboard() - return "进线登记成功", nil + // PLC↔MES 对账(#8 T5 建档提交):提示不拦,仅透出 mismatch 供终端弹窗 + mm, _ := s.detectAndRecord(ctx, station, "terminal", wp.OrderNo, operator) + return "进线登记成功", mm, nil } // reonlineWorkpiece 重上线(暂存退库后再次进线): @@ -222,10 +236,10 @@ func (s *Service) onlineNewWorkpiece(ctx context.Context, wp *ent.Workpiece, req // 顺序保证:校验全部通过后才产生出库这一副作用,避免"已出库却登记失败"的悬挂状态; // ③ 下一站工位当天停单时提示"工位N已停止接单"(复用 GetStationPaused 既有停单判定,不阻断登记)。 // 出库一次解锁一次(一.5):置回 ONLINE 并写物理位置 at_station=下一站;记生命周期 SEMI_OUT。 -func (s *Service) reonlineWorkpiece(ctx context.Context, wp *ent.Workpiece, req OnlineReq, operator string) (string, error) { +func (s *Service) reonlineWorkpiece(ctx context.Context, wp *ent.Workpiece, req OnlineReq, operator string) (string, *PlcMesMismatch, error) { items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, s.workpieceWorkOrder(ctx, wp)) if len(items) == 0 { - return "", errors.New("工单未配置工艺组合") + return "", nil, errors.New("工单未配置工艺组合") } next, nextFlow := 0, 0 for _, it := range items { @@ -234,19 +248,19 @@ func (s *Service) reonlineWorkpiece(ctx context.Context, wp *ent.Workpiece, req } } if next == 0 { - return "", fmt.Errorf("工件已报工至工位%d,工艺组合中无下一站", wp.CurrentStationNo) + return "", nil, fmt.Errorf("工件已报工至工位%d,工艺组合中无下一站", wp.CurrentStationNo) } // 二.4 资格校验:半成品(SEMI_STORED)重上线落点须为后续工序工位(=下一站);未传落点时按下一站兜底 if req.StationNo > 0 && req.StationNo != next { - return "", fmt.Errorf("半成品重上线须落在后续工序工位(工位%d),当前落点工位%d不符合资格", next, req.StationNo) + return "", nil, fmt.Errorf("半成品重上线须落在后续工序工位(工位%d),当前落点工位%d不符合资格", next, req.StationNo) } if err := s.SemiFlow(ctx, SemiReq{Sn: wp.Sn, OrderNo: wp.OrderNo, Action: "OUTBOUND"}, operator); err != nil { - return "", fmt.Errorf("重上线失败:%s", err.Error()) + return "", nil, fmt.Errorf("重上线失败:%s", err.Error()) } // 出库一次解锁一次(问题.md 一.5):置回 ONLINE,写物理位置=下一站,等待在所选工位重新上线建档。 if _, e := s.ctx.EntClient.Workpiece.UpdateOneID(wp.ID). SetStatus("ONLINE").SetAtStationNo(next).Save(ctx); e != nil { - return "", fmt.Errorf("重上线解锁状态失败:%s", e.Error()) + return "", nil, fmt.Errorf("重上线解锁状态失败:%s", e.Error()) } // 二.2 物理位置 + 三.2 状态流水 SEMI_STORED→ONLINE(出库 SEMI_OUT) s.writeLifecycle(ctx, wp.Sn, wp.OrderNo, "SEMI_STORED", "ONLINE", next, 0, operator, "workstation", "半成品出库重上线") @@ -257,7 +271,9 @@ func (s *Service) reonlineWorkpiece(ctx context.Context, wp *ent.Workpiece, req s.ctx.EventLog.Write(ctx, "workpiece.reonline", wp.OrderNo, operator, "workpiece", wp.Sn, "工件重上线(暂存退库后出库继续)", map[string]any{"nextStationNo": next, "nextFlowId": nextFlow}) s.notifyDashboard() - return msg, nil + // PLC↔MES 对账(#8 T5 建档提交):提示不拦,仅透出 mismatch 供终端弹窗 + mm, _ := s.detectAndRecord(ctx, next, "terminal", wp.OrderNo, operator) + return msg, mm, nil } // writeLifecycle 写工件生命周期状态流水(三.2 / P2 定稿:所有 status 变更点同事务写)。 @@ -348,6 +364,11 @@ func (s *Service) ReportProcess(ctx context.Context, req ReportProcessReq, opera if req.Sn == "" || req.StationNo <= 0 { return errors.New("sn 与 stationNo 必填") } + // PLC↔MES 对账(#8 T4 报工提交):命中 mismatch 则阻断报工,提示先处理该工位托盘位异常 + // (新件建档 / 绑定已知件 / 报异常 / 忽略),避免在无 MES 在制工件状态下误报工。 + if m, _ := s.detectAndRecord(ctx, req.StationNo, "report", "", operator); m != nil { + return fmt.Errorf("PLC与MES对账不一致:%s。请先处理该工位托盘位异常(新件建档 / 绑定已知件 / 报异常 / 忽略)后再报工", m.Detail) + } wp, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.Sn(req.Sn)).First(ctx) if err != nil { return errors.New("工件未进线登记") diff --git a/bj_power_mes/internal/plc/mock.go b/bj_power_mes/internal/plc/mock.go index b9ffefa..712fb45 100644 --- a/bj_power_mes/internal/plc/mock.go +++ b/bj_power_mes/internal/plc/mock.go @@ -13,10 +13,13 @@ type mockClient struct { mu sync.RWMutex // dockPallet 模拟接驳台是否有托盘:默认全部无托盘;联调时可用 SetDockPallet 置位 dockPallet map[string]bool + // stationPallet 模拟工位托盘位是否有件(PLC↔MES 对账用):key=工位号,默认全部无件; + // 联调/自测时可用 SetStationPallet 置位,模拟“PLC 说有位、MES 说无工件”的 mismatch 场景。 + stationPallet map[int]bool } func newMockClient() *mockClient { - return &mockClient{dockPallet: map[string]bool{}} + return &mockClient{dockPallet: map[string]bool{}, stationPallet: map[int]bool{}} } // SetDockPallet 手动设置某接驳台是否有托盘(供联调/测试用) @@ -26,6 +29,13 @@ func (m *mockClient) SetDockPallet(dockCode string, has bool) { m.dockPallet[dockCode] = has } +// SetStationPallet 手动设置某工位托盘位是否有件(PLC↔MES 对账联调/自测用) +func (m *mockClient) SetStationPallet(stationNo int, has bool) { + m.mu.Lock() + defer m.mu.Unlock() + m.stationPallet[stationNo] = has +} + func (m *mockClient) SendProcessCode(_ context.Context, combination string) ([]int, error) { codes := parseCombination(combination) m.sent = combination @@ -49,4 +59,11 @@ func (m *mockClient) QueryDockPallet(_ context.Context, dockCode string) (bool, m.mu.RLock() defer m.mu.RUnlock() return m.dockPallet[dockCode], nil +} + +// QueryStationPallet 读工位托盘位(mock):返回置位值,默认无件。 +func (m *mockClient) QueryStationPallet(_ context.Context, stationNo int) (bool, error) { + m.mu.RLock() + defer m.mu.RUnlock() + return m.stationPallet[stationNo], nil } \ No newline at end of file diff --git a/bj_power_mes/internal/plc/plc.go b/bj_power_mes/internal/plc/plc.go index 3c80c05..420aaf6 100644 --- a/bj_power_mes/internal/plc/plc.go +++ b/bj_power_mes/internal/plc/plc.go @@ -22,6 +22,11 @@ type Client interface { // QueryDockPallet 查询某接驳台(DOCK01..21)当前是否有托盘(读 PLC 托盘传感器信号)。 // 用于 AGV 到达目的地前确认接驳台空闲。暂未接真实 PLC 时 mock 返回 false(默认无托盘)。 QueryDockPallet(ctx context.Context, dockCode string) (bool, error) + // QueryStationPallet 查询某工位(stationNo)托盘位是否有件(读 PLC 工位托盘传感器信号)。 + // 用于 PLC↔MES 对账(#8):PLC 说有位、MES 说无工件 ⇒ mismatch。 + // 暂未接真实 PLC 时 mock 按置位返回(默认无件);真实 S7 对接待 PLC 点位表 + // (G1~G10→M895.0~M896.1、C15→M898.0)后由 tcp 实现补读寄存器逻辑。 + QueryStationPallet(ctx context.Context, stationNo int) (bool, error) } // Manager 管理 PLC 客户端实例 @@ -54,6 +59,16 @@ func (m *Manager) SetMockDockPallet(dockCode string, has bool) { } } +// SetMockStationPallet 仅在 mock 模式下生效:手动置位某工位托盘位是否有件(PLC↔MES 对账联调用)。 +func (m *Manager) SetMockStationPallet(stationNo int, has bool) { + if !m.mock { + return + } + if mc, ok := m.client.(*mockClient); ok { + mc.SetStationPallet(stationNo, has) + } +} + // parseCombination 解析工位组合 "1,3,5" / "10,11,12" -> [1,3,5] / [10,11,12] func parseCombination(s string) []int { var out []int diff --git a/bj_power_mes/internal/plc/tcp.go b/bj_power_mes/internal/plc/tcp.go index 3e4516f..1c081d8 100644 --- a/bj_power_mes/internal/plc/tcp.go +++ b/bj_power_mes/internal/plc/tcp.go @@ -32,4 +32,11 @@ func (t *tcpClient) AckDone(_ context.Context, ok bool) { // 信号定义未确认前返回 false(默认无托盘),待现场 PLC 点位表给到后在此处补读寄存器逻辑。 func (t *tcpClient) QueryDockPallet(_ context.Context, _ string) (bool, error) { return false, nil +} + +// QueryStationPallet 读工位托盘位(PLC↔MES 对账)。真实对接:按工位号映射 PLC 寄存器 +// (G1~G10→M895.0~M896.1、C15→M898.0)。信号定义未确认前返回 false(默认无件), +// 待现场 PLC 点位表给到后在此处补读寄存器逻辑(与 QueryDockPallet 同为占位实现)。 +func (t *tcpClient) QueryStationPallet(_ context.Context, _ int) (bool, error) { + return false, nil } \ No newline at end of file diff --git a/产线交互.md b/产线交互.md new file mode 100644 index 0000000..7e9f818 --- /dev/null +++ b/产线交互.md @@ -0,0 +1,202 @@ +# 产线交互 + +> 〔整理说明:用户原话一字不动(含错字);【原话】为用户原话标记。〕 +> +> 相关文件:产线布局说明.md(点位权威源,首行禁止 AI 改动,AI 只读)、问题.md、计划.md。 + +--- + +## 一、总原则 + +**先识别、后流转。** + +- 工件必须先被识别(扫码得 SN),MES 才知道工单、工艺、目标工位。 +- 点表里每一步移动都是一条指令。MES 不知道 SN → 算不出目标 → 一条指令都发不出去。 +- 工件在原地被识别之前,MES 不发任何流转指令。 +- SN 由工单预生成 → 扫 SN 即知工单归属。 +- 原设想"工件先流转到第一个启用工位再扫码"不成立——正确做法:就地扫、MES 送到正确工位。 + +--- + +## 二、命名 + +| 中文 | 英文 | 编号 | 定义 | +|---|---|---|---| +| 缓存位 | buffer position | C2/C3、C5/C6、C8/C9、C11/C12、C14 | 可缓存托盘,不顶升 | +| 停靠位 | dock position | C1/C4/C7/C10/C13/C15 | 正对工位,不缓存 | +| 工位 | station | G1~G12 | 加工位 | + +C1~C15 统称主线位置(main line position)。 + +--- + +## 三、PLC 通信 + +1. **下发前四查**:起始位有托盘 / 目标位空 / 途经无阻挡 / MW=0(上一条指令已完成)。 +2. **下发**:MES 向 MW 写非零值。 +3. **执行**:PLC 收到后执行路径移动(含自动顶升进工位)。 +4. **轮询**:MES 延时 2 秒起,轮询该 MW。 +5. **判完成**:读到 MW=0,且目标位传感器=1。 + - MW=0 但目标位传感器=0 → 异常报警(可能没收到、或托盘未到)。 + - 目标位传感器=1 但 MW 迟迟不为 0 → 超时报警(PLC 未清零)。 +6. **清零**:由 PLC 完成(点表 §4.3:PLC 在托盘移动到目标后给该地址清零)。**MES 不写 0。** +7. **超时**:30 秒未完成 → 报警,人工确认后重发。 + +【补充规则】 + +- **在途指令互斥**:MES 侧调度锁——目标位/途经位有在途指令时不下发(防两条不同 MW 的指令抢同一位置)。 + +--- + +## 四、上料 + +### 新件 + +1. 建工单,按数量预生成 SN(全 NEW)。 +2. 人工放件。**落点受限(主线单向)**: + - 工序1所在工位,或 + - 主线位 ≤ 工序1工位停靠位(默认 C1)。 + - 放其他位置 → 建档界面给提示"主线单向无法送达",不拦(人工搬兜底)。 +3. 就地识别:pad 任意位置扫,或所在工位终端扫(C1/G1/G2 只是常见例子)。 +4. 建档:起点 = 工序1,目标 = 工序1所在工位。 +5. NEW → ONLINE。 +6. MES 算路径 → 四查 → 下发。 + +### 半成品 + +【原话】"半成品,也可以放到 c1、或任何位置,上线建档,开始流转到 它应该继续的工艺 对应的 工位。" + +1. 在库(SEMI_STORED,入库次数有记录)。 +2. 出库解锁;工件放到任意位置(C1 或任意工位/主线位)。**同样受可达性约束**:落点 ≤ 建档工位停靠位,否则给提示不拦。 +3. 就地识别:终端扫(扫 SN 即知工单与已做工艺)。 +4. 建档:起点默认按已做推(可改,改了给提示但不拦),目标 = 应继续工艺对应的工位。 +5. ONLINE。 +6. MES 算路径 → 四查 → 下发。 + +### 建档界面 + +- 允许选择上料位(工件当前位置);选项 = 工位 + 主线位(C1~C15)。 +- 默认值:【原话】"默认值 是 c1"。 + +### 目标工位选择(一工艺多工位) + +【原话】"例如 工艺3(工位7/8/9) , 都是开工状态时, 空闲优先、多个空闲时,号越小越优秀,即 优先级7>8>9" + +- 同一工艺对应多个工位时,按以下顺序选目标: + 1. 空闲优先(无在制工件) + 2. 多个空闲 → 号小优先(7 > 8 > 9) + +--- + +## 五、工位间流转 + +- 四类路由(A/B/C/D),据点表 §4.4。 +- 全部 MES 算 → 四查 → 下发。 +- 方向约束据点表 §三.6。 +- 顶升由 PLC 自动完成,无需人工操作。C 类 = 主线位 → 工位(含顶升),一指令走完,完成判据 = 目标工位传感器 = 1(G1~G12 均有信号)。 +- **工位出料(A/B 类)自动**:【原话】"自动,像plc发送命令,流转到 缓存位、或、下一个工艺对应的工位。" + +--- + +## 六、缓存 + +### 取件顺序 + +- 下游优先(C3 先于 C2)。主线单向、不能超车。 + +### 缓存位的逻辑归属 + +- 可用缓存位 = 当前工艺尾部工位 与 下一工艺头部工位 之间的主线缓存位(不含停靠位)。 +- 例:工艺1(工位1/2/3)→ 工艺2(工位4/5/6):G3 与 G4 共用停靠位 C4 → 之间无缓存位。 +- 例(跳过工艺2):工艺1(工位1/2/3)→ 工艺3(工位7/8/9):G3 到 G7 之间 = C5、C6、C8、C9(C7 是停靠位,不算)。 + +### 单工单 vs 多工单 + +- 单工单:按配置可缓存。 +- 多工单:不缓存。原因:无法判断缓存位上的工件属于哪个工单、下一步去哪。 +- 【原话】"mes配置信息里面可以配置,配置要说清楚 紧着针对单个工单,多工单时 即使配置可缓存,也无法缓存。" +- 代价:多工单时件必须工位→工位直达;目标工位忙 → 件留在源工位 → 全线背压。 + +### 不自动前移,MES 逐格推进 + +【原话】"主线托盘会自动前移吗(不需要 D 类指令)? 不会" +【原话】"选择b,并且mes 要记录每个工件的位置,业务需求,没办法" + +1. 前方空一格 → 下发一格。 +2. 非目标的停靠位必须跨过,不能停(停靠位 C4/C7/C10/C13 没有 D 类起始地址)→ 跳格(如 C6→C8,跨过 C7)。 + - 可作起点的位置:C1、C2、C3、C5、C6、C8、C9、C11、C12、C14。 +3. 终点 = 目标停靠位。 +4. 下游优先。 + +--- + +## 七、下料完工 + +- 任何工序可下线。 +- 分流:工艺未结束 → SEMI_STORED;结束 → DONE。 +- 出线:【原话】"件到 G11/G12 检测完怎么出线?人工/塔吊,mes不用管" + +### 下料位选择 + +【原话】"允许选择,不选择,默认 c11 c12 ,哪个空闲就去哪里,都空闲 随意选,都忙碌,到 缓存位。工艺之间的缓存位,都满,工件在工位等着,等待触发。" + +- 下料目标 = G11、G12(两个末端下料检测位,均有在位信号:工位11 = M896.2、工位12 = M896.3)。 +- 人工可指定下料位。 +- 不指定时自动: + 1. 首选:上排工位 → G11;下排工位 → G12。首选空闲即去。 + 2. 首选忙、另一个空闲 → 去另一个。 + 3. 两个都空闲 → 按首选。 + 4. 两个都忙 → 工件流转到可用缓存位等待。 + 5. 缓存位也满 → 工件留在原工位等待。 + +--- + +## 八、位置台账 + +【原话】"mes 要记录每个工件的位置,业务需求,没办法" + +| 位置 | 当前 SN | 状态 | +|---|---|---| +| C1~C15 | SN 或 空 | 已知件 / 未知件(已占未扫) | +| G1~G12 | SN 或 空 | 加工中 | + +更新时机(任一位置,非仅工位): + +1. 每条指令完成 → 源位清空、目标位记 SN。 +2. 任何位置传感器 0→1 且无在途指令 → 记"未知件"(上料未扫)。 +3. 任何位置传感器 1→0 且无在途指令 → 清空(下料/取走)。 +4. 有在途指令时,以指令完成事件为准(防指令与传感器双写竞争)。 + +注:#8 对账范围为 G1~G10 + C15;位置台账覆盖 C1~C15 + G1~G12。 + +--- + +## 九、对账(#8) + +- 触发 T2~T7(T1 不做)、两项处理(新件建档 / 绑定已知件)、T4 报工硬阻断。 +- 待拍 3 项(执行侧):supervisor override 端点是否建;T2/T3 落点;途经位判定细则。 + +--- + +## 十、问 PLC(已答) + +| # | 问题 | 答案 | +|---|---|---| +| 1 | 清零:谁做? | PLC 做(按点表 §4.3:托盘移动到目标后,PLC 给该地址清零)。MES 只读、不写 0。 | +| 2 | 主线托盘会自动前移吗? | 【原话】"不会" | +| 3 | 顶升进工位有没有 PLC 本地自动触发? | 【原话】"自动跑到工位3"(自动,无需人工按钮) | +| 4 | G11/G12 有无在位信号? | 有。工位11 = M896.2、工位12 = M896.3。 | + +--- + +## 待定项 + +无。 + +--- + +## 附录:点位表(最终版) + +- 位信号 48 个:工位1~12(M895.0~M896.3)、主线1~15(M896.4~M898.2)、工位接驳台 20(M900.0~M902.3)、库房位接驳台 1(M902.4);未用 M898.3~M899.7。 +- 末端下料检测位 G11/G12 有独立信号(M896.2 / M896.3)。 +- 与 产线布局说明.md §4.1 一致;该文件禁止 AI 改动,如有出入以点表原文为准。 \ No newline at end of file diff --git a/产线布局说明.md b/产线布局说明.md index 02e8762..e7efe93 100644 --- a/产线布局说明.md +++ b/产线布局说明.md @@ -2,7 +2,7 @@ ## 产线布局说明(主线位置编址版) -> 修正:主线位置统一编址 C1~C15(左→右);**没有独立缓存位**——缓存是主线位置的属性:正对工位的停靠位不缓存,其余位置可缓存。上料位 = C1。工位 1~12 与主线位置的对应见下表。 +> 修正:主线位置统一编址 C1~C15(左→右);**没有独立缓存位**——缓存是主线位置的属性:正对工位的停靠位不缓存,其余位置可缓存。工位 1~12 与主线位置的对应见下表。 > > 本文已与 PLC 点表逐条核对:信号地址、数值编码、握手时序与四类路由地址表见 **§四 PLC 点表与通信协议**。 > 命名说明:工位G 。缓存停靠位C 。接驳台分两部分 第一部分是工位接驳台,命名方式 工位名 + (R1\R2) 例如 工位1左右两个接驳台分别命名 G1R1 G1R2; 第二部分 库房接驳台,命名JBT21 @@ -13,7 +13,7 @@ ```text 主传送带:一条水平主线,位置编址 C1~C15(左→右) -上料位 :C1(人工投料,带传感器,PLC 上报在位) + 上排接驳台:G1R1 G1R2 G3R1 G3R2 G5R1 G5R2 G7R1 G7R2 G9R1 G9R2 [工位G11·下料检测] @@ -32,7 +32,7 @@ ``` **图例:** -- `[工位X]`:工位 1~10(有终端),11/12 为末端下料检测位(无终端) +- `[工位X]`:工位 1~10(有终端),11/12 检测位(无终端) - `C1~C15`:主线位置编号(左→右),即 PLC 点表"进入主线N号位置"中的位置号 - `[G1R1]`/`[G1R2]`: AGV 接驳台(AGV 点位) - `[库房位]`:库房位接驳台(AGV 点位),位置与用途待现场确认 @@ -42,7 +42,7 @@ | 位置 | 用途 | 可否缓存 | |------|------|---------| -| C1 | **上料位**(人工投料)+ 工位1/2 出料停靠 | 否 | +| C1 | 工位1/2 出料停靠 | 否 | | C2、C3 | 缓存位(工位1/2 与 3/4 之间) | **可** | | C4 | 工位3/4 出料停靠 | 否 | | C5、C6 | 缓存位(3/4 与 5/6 之间) | **可** | @@ -63,15 +63,15 @@ - 一条水平主传送带(主线)自左向右单向流动,位置编址 C1~C15;工位在主线上下两侧,托盘到停靠位后顶升进工位。 - 上排 5 个工位(1、3、5、7、9),末端为上排末端下料检测位(工位11)。 - 下排 5 个工位(2、4、6、8、10),末端为下排末端下料检测位(工位12)。 - - 工件流向:上料位 C1 → 1/2 → 3/4 → 5/6 → 7/8 → 9/10 → 末端 11 / 12(下料检测)。 + - 工件流向:C1 → 1/2 → 3/4 → 5/6 → 7/8 → 9/10 → 末端 11 / 12(下料检测)。 - 全线合计 12 个工位点位(10 个加工工位 + 2 个末端下料检测位)。 -2. **上料位(C1,带传感器)** - - 位置:主线左端 C1,兼作工位1/2 的出料停靠位。 - - 人工把工件放上主线,是全线唯一的上料入口。 - - 该点位带传感器,PLC 上报上料位是否有工件,上位机据此记账。 - - 点表说明:该传感器信号即 `主线1有无托盘 M896.2`,点表中没有单独的"上料位信号"地址。 - - 上料节拍取决于人工投料速度。 +2. **上料位(默认C1,可选择,见下面上料过程说明)** + - 放件:人工把托盘放到产线的一个位置上。可放的位置为主线的任意位置(C1~C15)或任意工位,放哪个位置由现场决定。 + - 上报:托盘放上后,该位置的传感器被触发,PLC 把“该位置有托盘”上报上位机。主线上每个位置各有一个在位信号(`主线N有无托盘`),点表中没有单独的上料信号。 + - 建档:操作工在目标工位的终端上执行上线建档,选择工件当前所在位置、选择起始工序,确定目标工位。 + - 送件:系统向 PLC 下发路径指令,PLC 控制主线把托盘送到目标工位正对的停靠位,顶升进工位,开始加工。 + 。 3. **工位终端** - 上排 5 个 + 下排 5 个工位 各配 1 个工位终端,共 10 个终端。 @@ -101,8 +101,8 @@ - **工位→工位**:共享同一停靠位的工位对(G1/G2、G3/G4、G5/G6、G7/G8、G9/G10、G11/G12)可双向互传:下排→上排 = G2→G1、G4→G3、G6→G5、G8→G7、G10→G9、G12→G11;跨停靠位对的流转只能"向后"(目标工位号 > 源工位号)。 - **工位→主线**:目标位置必须 ≥ 本工位对的停靠位。G1/G2 可进 C1~C15;G3/G4 只能进 C4~C15;G5/G6 只能进 C7~C15;G7/G8 只能进 C10~C15;G9/G10 只能进 C13~C15;G11/G12 只能进 C15。 - **主线→工位**:C1 可进 G1~G12;C2/C3 只能进 G3~G12;C5/C6 只能进 G5~G12;C8/C9 只能进 G7~G12;C11/C12 只能进 G9~G12;C14/C15 只能进 G11~G12。 - - **主线→主线**:只有上料位与缓存位(C1、C2、C3、C5、C6、C8、C9、C11、C12、C14)可作为起点,目标位置必须 > 源位置。 - - 停靠位(C4/C7/C10/C13)**没有以它们为起点的指令地址**——工件一到达即顶升进工位;但停靠位可以作为主线→主线的目标位置(如 304 = C3 → C4)。 + - **主线→主线**:C1、C2、C3、C5、C6、C8、C9、C11、C12、C14,目标位置必须 > 源位置。 + - 停靠位(C4/C7/C10/C13) 工件一到达即顶升进工位;但停靠位可以作为主线→主线的目标位置(如 304 = C3 → C4)。 7. **其他说明** - 主传送带流转与停靠由PLC统一控制;是否允许缓存由位置属性决定(见编址表)。 @@ -121,7 +121,7 @@ | 工位1后接驳台1 / 接驳台2 | G1R1 / G1R2(工位2~10 同理,接驳台1 = R1、接驳台2 = R2) | | 库房位接驳台 | JBT21 | -#### 4.1 位地址信号(BOOL,46 个,逐条列全) +#### 4.1 位地址信号(BOOL,48 个,逐条列全) 语义:缓存位、接驳台、工位上都只能放一个托盘,托盘上即工件;信号 = 1 表示该位置有托盘(被占用)。 @@ -137,21 +137,23 @@ | 工位8有无托盘 | M895.7 | 工位G8 | | 工位9有无托盘 | M896.0 | 工位G9 | | 工位10有无托盘 | M896.1 | 工位G10 | -| 主线1有无托盘 | M896.2 | C1(即上料位传感器信号) | -| 主线2有无托盘 | M896.3 | C2 | -| 主线3有无托盘 | M896.4 | C3 | -| 主线4有无托盘 | M896.5 | C4 | -| 主线5有无托盘 | M896.6 | C5 | -| 主线6有无托盘 | M896.7 | C6 | -| 主线7有无托盘 | M897.0 | C7 | -| 主线8有无托盘 | M897.1 | C8 | -| 主线9有无托盘 | M897.2 | C9 | -| 主线10有无托盘 | M897.3 | C10 | -| 主线11有无托盘 | M897.4 | C11 | -| 主线12有无托盘 | M897.5 | C12 | -| 主线13有无托盘 | M897.6 | C13 | -| 主线14有无托盘 | M897.7 | C14 | -| 主线15有无托盘 | M898.0 | C15(末端下料检测位在位信号) | +| 工位11有无托盘 | M896.2 | 工位G11 | +| 工位12有无托盘 | M896.3 | 工位G12 | +| 主线1有无托盘 | M896.4 | C1 | +| 主线2有无托盘 | M896.5 | C2 | +| 主线3有无托盘 | M896.6 | C3 | +| 主线4有无托盘 | M896.7 | C4 | +| 主线5有无托盘 | M897.0 | C5 | +| 主线6有无托盘 | M897.1 | C6 | +| 主线7有无托盘 | M897.2 | C7 | +| 主线8有无托盘 | M897.3 | C8 | +| 主线9有无托盘 | M897.4 | C9 | +| 主线10有无托盘 | M897.5 | C10 | +| 主线11有无托盘 | M897.6 | C11 | +| 主线12有无托盘 | M897.7 | C12 | +| 主线13有无托盘 | M898.0 | C13 | +| 主线14有无托盘 | M898.1 | C14 | +| 主线15有无托盘 | M898.2 | C15 | | 工位1后接驳台1有无 | M900.0 | G1R1 | | 工位1后接驳台2有无 | M900.1 | G1R2 | | 工位2后接驳台1有无 | M900.2 | G2R1 | @@ -173,11 +175,10 @@ | 工位10后接驳台1有无 | M902.2 | G10R1 | | 工位10后接驳台2有无 | M902.3 | G10R2 | | 库房位接驳台有无 | M902.4 | JBT21 | -| (点表未列) | M898.1 ~ M899.7 | 按地址间隙推断为保留,未使用 | +| (点表未列) | M898.3 ~ M899.7 | 按地址间隙推断为保留,未使用 | 说明: -- 工位11/12(G11/G12,末端下料检测位)没有独立的"有无托盘"信号,末端下料在位以 C15(`主线15有无托盘 M898.0`)判断。 -- 位信号共 46 个:工位 10 + 主线 15 + 工位接驳台 20 + JBT21 1。 +- 位信号共 48 个:工位 12 + 主线 15 + 工位接驳台 20 + JBT21 1。 - 接驳台装有 PLC 传感器(有无托盘信号);PLC 只读,不控制接驳台/AGV 动作。 #### 4.2 数值编码规则(点表"数值释义") @@ -200,7 +201,7 @@ > 实现建议:加超时与重试,避免路径异常时无限轮询。 -#### 4.4 路由地址表(44 个 MW、323 条数值:点表 318 + 生产补充 5,逐条列全) +#### 4.4 路由地址表(44 个 MW、315 条数值,逐条列全) **A. 工位出料到主线(12 个地址、92 条数值)** @@ -320,7 +321,7 @@ MW820(11号工位出料到主线 = G11 出料到主线): MW822(12号工位出料到主线 = G12 出料到主线): - 1215 = 12号工位进入主线15号位置 = **G12 → C15** -**B. 工位出料到工位(11 个地址、72 条数值,含 5 条生产补充)** +**B. 工位出料到工位(11 个地址、72 条数值)** MW824(1号工位出料到工位 = G1 出料到工位): - 102 = 1号工位进入2号工位 = **G1 → G2** @@ -336,7 +337,7 @@ MW824(1号工位出料到工位 = G1 出料到工位): - 112 = 1号工位进入12号工位 = **G1 → G12** MW826(2号工位出料到工位 = G2 出料到工位): -- 201 = 2号工位进入1号工位 = **G2 → G1**(生产补充) +- 201 = 2号工位进入1号工位 = **G2 → G1** - 203 = 2号工位进入3号工位 = **G2 → G3** - 204 = 2号工位进入4号工位 = **G2 → G4** - 205 = 2号工位进入5号工位 = **G2 → G5** @@ -360,7 +361,7 @@ MW828(3号工位出料到工位 = G3 出料到工位): - 312 = 3号工位进入12号工位 = **G3 → G12** MW830(4号工位出料到工位 = G4 出料到工位): -- 403 = 4号工位进入3号工位 = **G4 → G3**(生产补充) +- 403 = 4号工位进入3号工位 = **G4 → G3** - 405 = 4号工位进入5号工位 = **G4 → G5** - 406 = 4号工位进入6号工位 = **G4 → G6** - 407 = 4号工位进入7号工位 = **G4 → G7** @@ -380,7 +381,7 @@ MW832(5号工位出料到工位 = G5 出料到工位): - 512 = 5号工位进入12号工位 = **G5 → G12** MW834(6号工位出料到工位 = G6 出料到工位): -- 605 = 6号工位进入5号工位 = **G6 → G5**(生产补充) +- 605 = 6号工位进入5号工位 = **G6 → G5** - 607 = 6号工位进入7号工位 = **G6 → G7** - 608 = 6号工位进入8号工位 = **G6 → G8** - 609 = 6号工位进入9号工位 = **G6 → G9** @@ -396,7 +397,7 @@ MW836(7号工位出料到工位 = G7 出料到工位): - 712 = 7号工位进入12号工位 = **G7 → G12** MW838(8号工位出料到工位 = G8 出料到工位): -- 807 = 8号工位进入7号工位 = **G8 → G7**(生产补充) +- 807 = 8号工位进入7号工位 = **G8 → G7** - 809 = 8号工位进入9号工位 = **G8 → G9** - 810 = 8号工位进入10号工位 = **G8 → G10** - 811 = 8号工位进入11号工位 = **G8 → G11** @@ -408,7 +409,7 @@ MW840(9号工位出料到工位 = G9 出料到工位): - 912 = 9号工位进入12号工位 = **G9 → G12** MW842(10号工位出料到工位 = G10 出料到工位): -- 1009 = 10号工位进入9号工位 = **G10 → G9**(生产补充) +- 1009 = 10号工位进入9号工位 = **G10 → G9** - 1011 = 10号工位进入11号工位 = **G10 → G11** - 1012 = 10号工位进入12号工位 = **G10 → G12** @@ -514,7 +515,7 @@ MW866(主线15号到各工位位置 = C15 到各工位): > 停靠位 C4、C7、C10、C13 没有本类地址(点表中不存在"主线4/7/10/13号到各工位位置")。 -**D. 主线到主线各位置(10 个地址、87 条数值)** +**D. 主线到主线各位置(10 个地址、79 条数值)** MW868(主线1号到主线各位置 = C1 到主线各位置): - 102 = 主线1号进入主线2号位置 = **C1 → C2** diff --git a/计划.md b/计划.md index a014d7a..2e9e4ce 100644 --- a/计划.md +++ b/计划.md @@ -21,7 +21,7 @@ | 缺口 | 判定 | 处置 | |---|---|---| -| 1 PLC↔MES 对账(L1030) | 属实,此前遗漏 | 纳入阶段2,设计草案见"三",待拍板 P1 | +| 1 PLC↔MES 对账(L1030) | 属实,此前遗漏 | 已按 #8 定稿落地 mock 通道(事件驱动/两项选项/复用event_log),见"三" | | 2 SN 生成锚点 | 不是新缺口——你已选 B,原选项 B = **建工单时预生成** | 定为:建工单(CREATED)时按工单数量生成,"下发并开工"不生成;问题.md 一.2 措辞"工单下发"→"建工单"待修正(P3) | | 3 半成品入库记录无落点 | 属实,半满足 | 落点设计见"四",待拍板 P2 | | 4 current_station 未定 | 已定(问题.md 二.1:取最后报工位置) | 基础已具备,只差缺口1机制 | @@ -60,17 +60,31 @@ --- -## 三、缺口1 设计草案:PLC↔MES 对账(待拍板 P1) +## 三、缺口1 设计定稿:PLC↔MES 对账(#8,2026-10-13 拍板) 你的原话(L1030):"工位终端,自己选择。 mes 会记录在库 每个 成品的位置。当发现,工位x没有在库记录,但是plc点位标识有托盘,就可以让操作工选择。" -草案: -- 触发:定时轮询工位在位信号(M895.0~M896.1 十个工位)对比 MES current_station 汇总;间隔默认 30 秒(可配)。 -- 判定:工位有托盘(信号=1) 且 MES 无在库工件落在该工位 → 对账不一致。 -- 处置:终端/MES 弹出,操作工三选——① 新件建档 ② 绑定已知件(纠正位置)③ 忽略(记日志)。 -- 反向对账(MES 有记录但 PLC 无托盘):第一版只提示不强制。 +### 定稿口径 +- **触发:事件驱动(禁止定时轮询)**,六触发点(T1 标记不做): + - T2 终端开始作业 → 单工位检查(仅 event_log) + - T3 终端扫 SN → 单工位检查(仅 event_log) + - T4 报工提交 → 命中则**硬阻断报工**(单工位,仅 event_log)【已落地:ReportProcess 阻断】 + - T5 建档提交 → 单工位检查,命中仅提示不拦(仅 event_log)【已落地:OnlineWorkpiece 透出 mm】 + - T6 PLC 通讯恢复 → 全量 11 位检查,落预警中心(event_log + alert) + - T7 管理员手动核对 → 全量 11 位检查,落预警中心(event_log + alert) +- **判定**:工位 PLC 托盘位=1 且 MES 无 status∈{ONLINE,PROCESSING} 工件落该工位 且 工位非 DISABLED 且 不在「工序码下发后 15 秒」宽限 → `plc_mes_mismatch`。 +- **对账范围(读 PLC 真值)**:G1~G10(M895.0~M896.1)+ 末端下料检测位 C15(M898.2,映射 MES 工位号 15);共 11 位。G11/G12 已有独立信号(M896.2/M896.3),本轮不纳入对账(该处无终端可处置),后续可选。 +- **处置选项(两项,闭环)**:`new_workpiece`(新件建档)/ `bind_known`(绑定已知件)。删除原草案的 忽略/报异常(无法闭环)。 + - 闭环保证:两项均为既有业务动作,执行后该工位即存在在制工件 → 下次检测不再 mismatch,天然闭环。 + - 强制闭环(两项都处理不了=误报):该工位作业**阻断**,由有权限者经 supervisor override 端点确认误报并关闭(记 event_log,trigger=supervisor_override,不建工件),与"操作工自行忽略"严格区分。 +- **数据落点**:复用 `event_log`(plc_mes_mismatch) + `alert`(仅 T6/T7 系统触发),**不建独立表**。 +- **PLC 真读**:点位表已具备(产线布局说明.md §4.1/§4.3/§4.4),无阻塞项;tcp.go 实现 48 位 BOOL 真读 + §4.3 握手 + 下发前「起始位有托盘 + 路线无阻挡」双校验(与路径指令下发共用同一 PLC 读层)。 -待拍:做不做 / 轮询间隔 / 三选项是否够。 +### 真读与路径下发共用层(tcp.go) +- 读 48 位 BOOL:M895.0~M898.2(工位12+主线15)+ M900.0~M902.4(接驳台20+库房1),一次按字节块读 MB895~MB902(8 字节)后按位索引。 +- 路由表(§4.4,44 个 MW,不规则,须逐条转录):值=源×100+目标(§4.2);A 类工位→主线(MW800+2*(src-1))、B 类工位→工位(MW824 起)、C 类主线→工位、D 类主线→主线(MW886=C14→主线);C4/C7/C10/C13 主线源跳过。 +- 下发时序(§4.3):写非零值→延时 2s→轮询读 0=完成(清零由 PLC 做,MES 只读不写 0);加超时报警,人工确认后重发。 +- 新增下发前校验:① 起始位有托盘(源位信号=1;G11/G12 已有独立信号 M896.2/M896.3,同样校验);② 路线无阻挡(目标位空闲 + 主线途经位空闲,单向 C1→C15 右向流动;保守默认:目标位被占即阻挡,主线内移动再加验途经位)。两项不全满足 → 不下发,返回明确错误由人工确认。 --- @@ -146,7 +160,7 @@ | # | 事项 | 选项 | |---|---|---| -| P1 | PLC↔MES 对账 | 做不做 / 轮询间隔 / 三选项够不够 | +| P1 | PLC↔MES 对账 | 已拍板定稿:事件驱动(T2-T7)/两项选项(new_workpiece,bind_known)/复用event_log,见三 | | P2 | 生命周期日志表 | 独立表 workpiece_lifecycle_log(推荐)/ 复用 eventlog | | P3 | 问题.md 一.2 措辞 | "工单下发"→"建工单(CREATED)" | | P4 | 阶段1 清单 | 核对上表 12 项后开工 |