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