Files
bj_power/bj_power_mes/internal/plc/tcp.go
T

303 lines
8.9 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 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
}
}