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

420 lines
15 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"
"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 {
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 位点位状态并按位置分组(工位/主线/接驳台+库房)。
func (s *Service) PlcMonitorBits(ctx context.Context) (*BitsGroup, error) {
bits, err := s.ctx.PLC.Get().ReadBits(ctx)
if err != nil {
return nil, err
}
g := &BitsGroup{}
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 即在途指令)。
func (s *Service) PlcMonitorMW(ctx context.Context) ([]MWState, error) {
addrs := plc.AllRouteAddrs()
out := make([]MWState, 0, len(addrs))
for _, addr := range addrs {
val, err := s.ctx.PLC.Get().ReadMW(ctx, addr)
if err != nil {
return nil, err
}
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 路由表内)")
}
// 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
}
// ---------- 强制写入(块 D:PLC 强制写,危险操作,需二次确认) ----------
// ForceBitReq 强制写单个 M 位请求体。
type ForceBitReq struct {
MerkerByte int `json:"merkerByte"` // M 字节偏移(如 898 表示 MB898)
MerkerBit int `json:"merkerBit"` // 位 0..7
On bool `json:"on"` // true=置 1,false=清 0
Confirmed bool `json:"confirmed"` // 二次确认勾选,必须 true 才执行
}
// ForceResult 强制写 M 位结果。
type ForceResult struct {
Before bool `json:"before"` // 写前位值
After bool `json:"after"` // 写后即时回读位值(M 位可能被 PLC 程序覆盖,仅反映即时态)
}
// ForceMWResult 强制写 MW 结果。
type ForceMWResult struct {
Before int `json:"before"` // 写前值
After int `json:"after"` // 写入值
}
// PlcMonitorForceBit 强制置/复位单个 M 位(停机/调试用)。
// 必须二次确认(confirmed=true)才执行;M 位可能被 PLC 程序循环覆盖,结果不保证持久。
func (s *Service) PlcMonitorForceBit(ctx context.Context, req ForceBitReq, operator string) (*ForceResult, error) {
if !req.Confirmed {
return nil, errors.New("未勾选「确认执行强制写」:操作已拒绝")
}
if !plc.IsWritableMerkerByte(req.MerkerByte) || req.MerkerBit < 0 || req.MerkerBit > 7 {
return nil, errors.New("非法的 M 位地址(MB" + strconv.Itoa(req.MerkerByte) + "." + strconv.Itoa(req.MerkerBit) + ")")
}
before, after, err := s.ctx.PLC.Get().WriteBit(ctx, req.MerkerByte, req.MerkerBit, req.On)
if err != nil {
return nil, err
}
obj := "M" + strconv.Itoa(req.MerkerByte) + "." + strconv.Itoa(req.MerkerBit)
desc := "强制写 " + obj + ":" + boolToZh(before) + " → " + boolToZh(after) + "(" + onZh(req.On) + ")"
s.ctx.EventLog.Write(ctx, "plc_manual_force", "", operator, "plc", obj,
desc,
map[string]any{
"object": obj,
"before": before,
"after": after,
"target": req.On,
"operator": operator,
"confirmTime": time.Now().Format(time.RFC3339),
})
return &ForceResult{Before: before, After: after}, nil
}
// ForceMWReq 强制写 MW 请求体。
type ForceMWReq struct {
Addr int `json:"addr"` // MW 地址
Value int `json:"value"` // 写入值
Confirmed bool `json:"confirmed"` // 二次确认勾选,必须 true 才执行
}
// PlcMonitorWriteMw 强制写 16 位寄存器(MW)。
// 必须二次确认(confirmed=true)才执行;仅白名单内地址(MW800~886 + 4096~4099)允许,越界拒绝。
func (s *Service) PlcMonitorWriteMw(ctx context.Context, req ForceMWReq, operator string) (*ForceMWResult, error) {
if !req.Confirmed {
return nil, errors.New("未勾选「确认执行强制写」:操作已拒绝")
}
if !plc.IsWritableMW(req.Addr) {
return nil, errors.New("MW" + strconv.Itoa(req.Addr) + " 不在可写白名单内(仅允许 MW800~886 与 MW4096~4099),操作已拒绝")
}
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, req.Value); err != nil {
return nil, err
}
obj := "MW" + strconv.Itoa(req.Addr)
desc := "强制写 " + obj + ":" + strconv.Itoa(before) + " → " + strconv.Itoa(req.Value)
s.ctx.EventLog.Write(ctx, "plc_manual_force", "", operator, "plc", obj,
desc,
map[string]any{
"object": obj,
"before": before,
"after": req.Value,
"operator": operator,
"confirmTime": time.Now().Format(time.RFC3339),
})
return &ForceMWResult{Before: before, After: req.Value}, nil
}
func boolToZh(b bool) string {
if b {
return "1"
}
return "0"
}
func onZh(on bool) string {
if on {
return "置位"
}
return "复位"
}
// ---------- 工件位置纠正(块 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) {
bits, err := s.ctx.PLC.Get().ReadBits(ctx)
if err != nil {
return nil, 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
}
// ---------- 末端取件释放(块 H 收尾:G11/G12 无 PLC 传感器,取件必须人工确认) ----------
// EndPointOccupied 末端下料检测位(END-U=G11 上排 / END-D=G12 下排)的一条占用记录。
type EndPointOccupied struct {
PointNo string `json:"pointNo"` // 点位编号 END-U / END-D
Label string `json:"label"` // 点位名称
StationNo int `json:"stationNo"` // 对应工位 11/12
Sn string `json:"sn"` // 占用工件的 SN
OrderNo string `json:"orderNo"` // 来源:所属工单(占用记账时写入)
UpdatedAt int64 `json:"updatedAt"` // 占用时间(点位台账最后更新时间)
}
// ListEndPointOccupied 列出末端下料检测位(G11/G12)当前被占用的记录。
// G11/G12 无 PLC 传感器,工件被物理取走后点位台账不会自动清,必须人工确认释放。
func (s *Service) ListEndPointOccupied(ctx context.Context) ([]EndPointOccupied, error) {
pts, err := s.ctx.EntClient.LinePoint.Query().
Where(linepoint.PointType("END"), linepoint.Occupied(true)).
Order(ent.Asc(linepoint.FieldSeq)).All(ctx)
if err != nil {
return nil, err
}
out := make([]EndPointOccupied, 0, len(pts))
for _, p := range pts {
out = append(out, EndPointOccupied{
PointNo: p.PointNo,
Label: p.Label,
StationNo: p.StationNo,
Sn: p.CurrentSn,
OrderNo: p.OrderNo,
UpdatedAt: p.UpdatedAt.Unix(),
})
}
return out, nil
}
// ReleaseEndPointReq 末端取件释放请求体。
type ReleaseEndPointReq struct {
PointNo string `json:"pointNo"`
}
// ReleaseEndPoint 人工确认末端取件:释放 G11/G12 点位占用(OccupyPoint OUT)并写操作日志。
// 记 event_log(type=point_release_manual),含 SN、点位、操作人、释放时间、说明「人工确认末端取件」。
func (s *Service) ReleaseEndPoint(ctx context.Context, req ReleaseEndPointReq, operator string) error {
pointNo := strings.TrimSpace(req.PointNo)
if pointNo == "" {
return errors.New("缺少点位编号")
}
pt, err := s.ctx.EntClient.LinePoint.Query().Where(linepoint.PointNo(pointNo)).First(ctx)
if err != nil {
return errors.New("点位不存在:" + pointNo)
}
if pt.PointType != "END" {
return errors.New("仅支持释放末端下料检测位(G11/G12)")
}
if !pt.Occupied {
return errors.New("该点位当前未被占用,无需释放")
}
sn, orderNo := pt.CurrentSn, pt.OrderNo
// 释放点位(唯一事实源维护入口,内部写 line.point.out 流水)
if err := s.OccupyPoint(ctx, pointNo, sn, orderNo, operator, "OUT"); err != nil {
return err
}
now := time.Now().Unix()
s.ctx.EventLog.Write(ctx, "point_release_manual", orderNo, operator, "line_point", pointNo,
"人工确认末端取件:"+pointNo+"("+pt.Label+")",
map[string]any{
"object": "点位 " + pointNo,
"pointNo": pointNo,
"pointLabel": pt.Label,
"sn": sn,
"orderNo": orderNo,
"operator": operator,
"releasedAt": now,
"note": "人工确认末端取件",
})
return nil
}