package plc import ( "context" "fmt" "strconv" "strings" "sync" "time" "github.com/robinson/gos7" "bj_power_mes/internal/config" ) // 西门子 S7 真读:48 位块(MB895..MB902,8 字节)覆盖产线点位信号。 // // 真点位表(现场 PLC 工程师确认,2026-10 定稿): // - 工位托盘位 G1..G12 → 逻辑 0..11 (MB895.0..MB896.3) // - 主线缓存位 C1..C15 → 逻辑 12..26 (MB896.4..MB898.2,C15=M898.2) // - 工位接驳台托盘位 → 逻辑 27..47 (MB900.0..MB902.4) // DOCK01..DOCK20 → MB900.0..MB901.7(逻辑 27..46) // JBT21(库房接驳台)→ MB902.4(逻辑 47) // - 读块 MB895..MB902 共 8 字节;其中 MB898.3..MB899.7(逻辑位 27..39)为保留/注释段,读入后丢弃。 // // 逻辑 48 位索引 → 物理字节位偏移由 logicalToRaw 统一映射,ReadBits 经 decodeBits 还原。 const ( plcBlockStartByte = 895 plcBlockBytes = 8 // plcOpTimeout 单次 S7 网络操作的硬上限(拨号 + 一次读/写事务的收尾)。 // 2026-11-19 修正:原值 30s 与上层 plcHardCut 2.5s 严重错配——gos7 的 Send 用 // conn.SetDeadline(lastActivity+Timeout) 做读超时,30s 内不返回的读会把事务层 // 的串行闸一直占住;上层虽已 2.5s 硬切返回,底层 goroutine 仍在拨号/读,后续 // 每轮轮询全部堵在闸上 → 日志里成片 context deadline exceeded。现场实测正常 // 单次读 <50ms(诊断工具 17ms 建连),1.5s 已是极宽裕的容错,断电时也能Quick fail。 plcOpTimeout = 1500 * time.Millisecond ) // s7Real 真实西门子 S7 客户端(gos7),持有一条长连接,断线惰性重连。 // // 并发模型(2026-11-19 重构,修复 PLC 强制断链 / 重连风暴): // - gos7 的 Client 用同一个 TCPClientHandler/conn + 自增事务号收发,并非并发安全: // 两个 goroutine 同时在一条连接上做 AGReadMB,会出现请求-响应错配、读到半包、 // PLC 协议栈拒绝报文并主动 RST(日志里 "forcibly closed by the remote host")。 // - 因此连接建立 + 每一次读/写事务全程在 opMu 内串行执行,任何时刻只有一条 S7 事务在途。 // - 串行化后单事务耗时可控(<50ms),不会拖垮 3s 一轮的监控页快照 / 看板 SSE。 type s7Real struct { c config.PlcConf handler *gos7.TCPClientHandler client gos7.Client opMu sync.Mutex // 串行闸:连接 + 单次事务全程持有,保证 gos7 单连接不被并发访问 } func newS7Real(c config.PlcConf) *s7Real { h := gos7.NewTCPClientHandler(c.Host, c.Rack, c.Slot) h.Timeout = plcOpTimeout return &s7Real{c: c, handler: h} } // ensure 惰性连接 + 断线重连。调用方必须已持有 s.opMu。 // 用 ConnectContext 而非 Connect:gos7 的 Connect() 内部走 context.Background(), // 拨号不可打断;带 ctx 后上层 plcHardCut 硬切能真正取消拨号,不留后台 goroutine。 func (s *s7Real) ensure(ctx context.Context) error { if s.client != nil { return nil } if err := s.handler.ConnectContext(ctx); err != nil { return err } s.client = gos7.NewClient(s.handler) return nil } // run 在串行闸内执行一条 S7 事务:确保连接 → 执行 fn → 出错即断链(下轮惰性重连)。 // 拨号阶段认 ctx(可被上层硬切取消);读/写事务阶段由 gos7 的 plcOpTimeout 兜底。 func (s *s7Real) run(ctx context.Context, fn func(gos7.Client) error) error { s.opMu.Lock() defer s.opMu.Unlock() if err := s.ensure(ctx); err != nil { return err } if err := fn(s.client); err != nil { _ = s.handler.Close() s.client = nil return err } return nil } // readBlock 读取 48 位块(MB895..MB902)原始 8 字节。 func (s *s7Real) readBlock(ctx context.Context) ([]byte, error) { buf := make([]byte, plcBlockBytes) err := s.run(ctx, func(cl gos7.Client) error { return cl.AGReadMB(plcBlockStartByte, plcBlockBytes, buf) }) if err != nil { return nil, err } return buf, nil } // readByte 读取单个 Merker 字节(用于 48 位块之外的完成信号位等)。 func (s *s7Real) readByte(ctx context.Context, byteOffset int) (byte, error) { buf, err := s.readBytes(ctx, byteOffset, 1) if err != nil { return 0, err } return buf[0], nil } // readBytes 读任意 Merker 字节区间(串行闸内一次事务),供 ReadMWBlock 等批量读使用。 func (s *s7Real) readBytes(ctx context.Context, byteOffset, length int) ([]byte, error) { if byteOffset < 0 || length <= 0 { return nil, fmt.Errorf("非法读区间: offset=%d len=%d", byteOffset, length) } buf := make([]byte, length) err := s.run(ctx, func(cl gos7.Client) error { return cl.AGReadMB(byteOffset, length, buf) }) if err != nil { return nil, err } return buf, nil } // bit 取块内某位(bitOffset 0..47)。 func bit(buf []byte, offset int) bool { if offset < 0 || offset >= len(buf)*8 { return false } return buf[offset/8]&(1<<(offset%8)) != 0 } // dockOffset DOCK 编码 → 8 字节读块内的物理位偏移;JBT21 单独处理。 // 接驳台真实物理位落在 MB900.0..MB902.4(读块内偏移 40..60)。 func dockOffset(dockCode string) (int, bool) { dockCode = strings.ToUpper(strings.TrimSpace(dockCode)) if dockCode == "JBT21" { return 60, true // MB902.4 } if !strings.HasPrefix(dockCode, "DOCK") { return 0, false } n, err := strconv.Atoi(strings.TrimPrefix(dockCode, "DOCK")) if err != nil || n < 1 || n > 20 { return 0, false } return 40 + (n - 1), true // DOCK01→40(M900.0) ... DOCK20→59(M901.7), JBT21→60(M902.4) } // tcpClient 真实 S7 对接实现(替换原 mock 占位)。 type tcpClient struct { c config.PlcConf real *s7Real } func newTcpClient(c config.PlcConf) *tcpClient { return &tcpClient{c: c, real: newS7Real(c)} } // SendProcessCode 下发工位组合(如 "1,3,5"),返回已下发工位码。 // 真实 S7:应把组合码写入 PLC 工艺寄存器;寄存器地址待现场点位表确认,当前仅解析并打点。 func (t *tcpClient) SendProcessCode(_ context.Context, combination string) ([]int, error) { codes := parseCombination(combination) // TODO(PLC): 待点位表确认后在此 gos7.WriteArea 写入组合码寄存器 return codes, nil } // QueryDone 查询最近一次下发是否收到完成信号。 // 读 DoneByte.DoneBit(待点位表确认);未配置时安全返回 false(不下发下一条,不误进)。 func (t *tcpClient) QueryDone(ctx context.Context) (bool, error) { if t.c.DoneByte < 0 || t.c.DoneBit < 0 { return false, nil } b, err := t.real.readByte(ctx, t.c.DoneByte) if err != nil { return false, err } return b&(1<<(t.c.DoneBit%8)) != 0, nil } // AckDone 真实 S7 下完成由 PLC 自动置位,无需 MES 写;保留接口。 func (t *tcpClient) AckDone(_ context.Context, _ bool) {} // QueryDockPallet 读接驳台托盘传感器(AGV 到达目的地前确认接驳台空闲)。 func (t *tcpClient) QueryDockPallet(ctx context.Context, dockCode string) (bool, error) { offset, ok := dockOffset(dockCode) if !ok { return false, fmt.Errorf("未知接驳台编码: %s", dockCode) } buf, err := t.real.readBlock(ctx) if err != nil { return false, err } return bit(buf, offset), nil } // QueryStationPallet 读工位托盘位(PLC↔MES 对账 #8):G{stationNo} 位。 func (t *tcpClient) QueryStationPallet(ctx context.Context, stationNo int) (bool, error) { if stationNo < 1 || stationNo > 12 { return false, fmt.Errorf("工位号越界: %d", stationNo) } buf, err := t.real.readBlock(ctx) if err != nil { return false, err } return bit(buf, stationNo-1), nil } // logicalToRaw 逻辑 48 位索引 → 物理字节位偏移(8 字节读块内)。 // 工位(G)/主线(C) 段 0..26 物理与逻辑一致;接驳台段 27..47 物理落在 MB900.0..MB902.4(偏移 40..60)。 func logicalToRaw(o int) int { if o < 27 { return o } return o - 27 + 40 } // decodeBits 把 8 字节原始读块还原为逻辑 48 位(工位/主线/接驳台),丢弃 M898.3~M899.7 保留段。 func decodeBits(buf []byte) []bool { out := make([]bool, 48) for i := 0; i < 48; i++ { out[i] = bit(buf, logicalToRaw(i)) } return out } // ReadBits 读 48 位点位信号(§4.1,一次性读取不轮询): // 读 MB895..MB902 共 8 字节(64 位),经 logicalToRaw/decodeBits 还原为逻辑 48 位: // [0..11]G1..G12 [12..26]C1..C15 [27..46]DOCK01..DOCK20 [47]JBT21(接驳台物理位 MB900.0~MB902.4)。 func (t *tcpClient) ReadBits(ctx context.Context) ([]bool, error) { buf, err := t.real.readBlock(ctx) if err != nil { return nil, err } return decodeBits(buf), nil } // ReadMW 读 16 位寄存器(MW,大端):读 addr、addr+1 两字节拼成 16 位。 func (t *tcpClient) ReadMW(ctx context.Context, addr int) (int, error) { hi, err := t.real.readByte(ctx, addr) if err != nil { return 0, err } lo, err := t.real.readByte(ctx, addr+1) if err != nil { return 0, err } return int(hi)<<8 | int(lo), nil } // ReadMWBlock 批量读连续 MW 寄存器(大端):一次 AGReadMB 读 count*2 字节, // 避免逐地址读造成的 2*count 次 TCP 往返(看板快照用,MW800..MW887 一次取完)。 func (t *tcpClient) ReadMWBlock(ctx context.Context, start, count int) ([]int, error) { if start < 0 || count <= 0 || start+count*2 > 65536 { return nil, fmt.Errorf("非法 MW 批量读区间: start=%d count=%d", start, count) } buf, err := t.real.readBytes(ctx, start, count*2) if err != nil { return nil, err } out := make([]int, count) for i := 0; i < count; i++ { out[i] = int(buf[i*2])<<8 | int(buf[i*2+1]) } return out, nil } // WriteMW 写 16 位寄存器(MW,大端):高字节写 addr、低字节写 addr+1。 func (t *tcpClient) WriteMW(ctx context.Context, addr, value int) error { buf := []byte{byte(value >> 8), byte(value & 0xff)} return t.real.writeBuffer(ctx, addr, buf) } // writeBuffer 写任意 Merker 字节区间(供 WriteMW 调用),与读共用同一串行闸。 func (s *s7Real) writeBuffer(ctx context.Context, byteOffset int, data []byte) error { return s.run(ctx, func(cl gos7.Client) error { return cl.AGWriteMB(byteOffset, len(data), data) }) }