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 plcReadTimeout = 30 * time.Second ) // s7Real 真实西门子 S7 客户端(gos7),持有一条长连接,断线惰性重连。 type s7Real struct { c config.PlcConf handler *gos7.TCPClientHandler client gos7.Client mu sync.Mutex } func newS7Real(c config.PlcConf) *s7Real { h := gos7.NewTCPClientHandler(c.Host, c.Rack, c.Slot) h.Timeout = plcReadTimeout return &s7Real{c: c, handler: h} } // ensure 惰性连接 + 断线重连。 func (s *s7Real) ensure() error { if s.client != nil { return nil } if err := s.handler.Connect(); err != nil { return err } s.client = gos7.NewClient(s.handler) return nil } // readBlock 读取 48 位块(MB895..MB900)原始 6 字节。 func (s *s7Real) readBlock(ctx context.Context) ([]byte, error) { s.mu.Lock() cl := s.client need := cl == nil if need { if err := s.ensure(); err != nil { s.mu.Unlock() return nil, err } cl = s.client } s.mu.Unlock() buf := make([]byte, plcBlockBytes) done := make(chan error, 1) go func() { done <- cl.AGReadMB(plcBlockStartByte, plcBlockBytes, buf) }() select { case <-ctx.Done(): return nil, ctx.Err() case err := <-done: if err != nil { s.mu.Lock() _ = s.handler.Close() s.client = nil s.mu.Unlock() 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) } s.mu.Lock() if err := s.ensure(); err != nil { s.mu.Unlock() return nil, err } cl := s.client s.mu.Unlock() buf := make([]byte, length) done := make(chan error, 1) go func() { done <- cl.AGReadMB(byteOffset, length, buf) }() select { case <-ctx.Done(): return nil, ctx.Err() case err := <-done: if err != nil { s.mu.Lock() _ = s.handler.Close() s.client = nil s.mu.Unlock() 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 { s.mu.Lock() if err := s.ensure(); err != nil { s.mu.Unlock() return err } cl := s.client s.mu.Unlock() done := make(chan error, 1) go func() { done <- cl.AGWriteMB(byteOffset, len(data), data) }() select { case <-ctx.Done(): return ctx.Err() case err := <-done: if err != nil { s.mu.Lock() _ = s.handler.Close() s.client = nil s.mu.Unlock() return err } return nil } }