Files
bj_power/bj_power_mes/internal/plc/tcp.go
T
SunYF b0c048d9aa feat: 新增收集式校验错误弹窗及工位报警语音播报
新增 ErrorListDialog 组件用于统一展示结构化校验错误信息,实现报错一次收全;新增工位报警语音播报功能,通过浏览器 SpeechSynthesis 播放本工位相关报警;调整物料类别及序列号字段文案,移除「其他」类别;新增工单实际开始字段及采集方式配置;优化 AGV 及 PlcSend 页签刷新逻辑;新增看板物料追溯及工位报警接口;删除 PLC 强制写 M 位及相关测试代码;同步数据库字段注释及补丁。
2026-10-20 16:36:26 +08:00

274 lines
7.8 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) {
s.mu.Lock()
if err := s.ensure(); err != nil {
s.mu.Unlock()
return 0, err
}
cl := s.client
s.mu.Unlock()
buf := make([]byte, 1)
done := make(chan error, 1)
go func() { done <- cl.AGReadMB(byteOffset, 1, buf) }()
select {
case <-ctx.Done():
return 0, ctx.Err()
case err := <-done:
if err != nil {
s.mu.Lock()
_ = s.handler.Close()
s.client = nil
s.mu.Unlock()
return 0, err
}
return buf[0], 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
}
// 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
}
}