Files
bj_power/bj_power_workstation/internal/tightening/tightening.go
T
SunYF f65a52d9e1 feat: 多系统新增扫码中间件与 AGV 对接,优化拧紧与退库流程
新增扫码中间件支持网络型扫码枪键盘注入,AGV 对接从 WMS 迁至 MES 统一管理;新增拧紧不合格人工处置与 PLC 对账机制,优化退库单关联与工位终端功能,同时清理旧 AGV 任务表,完善数据库与配置项。
2026-10-14 17:24:59 +08:00

378 lines
11 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 tightening
import (
"bufio"
"context"
"fmt"
"net"
"strconv"
"strings"
"sync"
"time"
"github.com/zeromicro/go-zero/core/logx"
)
// 阿特拉斯·科普柯 Open Protocol(开放式协议,基于 TCP 文本报文)。
//
// 报文帧:[STX][长度(4位ASCII)][头部(20字节)][数据][ETX]
// 长度 = 头部(20) + 数据长度 + 1(ETX)
// 头部(20):MID(4) + 版本(3) + NoAck(1) + 工位号(4) + 备用(2) + 单元号(2) + 通道号(2) + 操作员号(2)
// 固定字段以 NUL/空格右补,解析数值时去除。
//
// 业务口径(2026-10 定稿):工位终端 1:1 连控制器,不区分哪把枪(控制器自行管理多枪);
// 控制器在每次拧紧完成后推送 MID 0061/0062 拧紧结果,终端接收后暂存,操作工在界面点「完成」
// 才经 POST /api/tightening/record 落本地库并上报 MES。故本模块只负责「接收+暂存+供前端轮询」,
// 不负责上报(上报仍走既有 tighteningRecordHandler + 同步器)。
const (
stx byte = 0x02
etx byte = 0x03
)
// TighteningConfig 拧紧枪控制器(阿特拉斯 Open Protocol)连接配置。
type TighteningConfig struct {
Enable bool `json:",default=false"` // 是否启用 OP 协议接入(false=仍走人工录入,兼容无控制器/调试环境)
ControllerAddr string `json:",default=127.0.0.1:4545"` // 控制器 IP:端口
CellID string `json:",default=01"`
ChannelID string `json:",default=01"`
StationID string `json:",default=0001"`
OperatorID string `json:",default=01"`
HeartbeatSec int64 `json:",default=8"`
}
// Result 一条来自控制器的拧紧结果(尚未经操作工确认上报 MES)。
type Result struct {
ID int64 `json:"id"`
Torque float64 `json:"torque"` // N·m
Angle float64 `json:"angle"` // 度
Result string `json:"result"` // OK | NG
RawMid string `json:"rawMid"` // 来源 MID(0061/0062)
ReceivedAt int64 `json:"receivedAt"` // 毫秒时间戳
Consumed bool `json:"consumed"` // 操作工是否已确认(点「完成」)
}
// Manager 拧紧枪 OP 接入管理:维护与控制器长连接、解析结果、提供最近结果供前端轮询。
type Manager struct {
cfg TighteningConfig
mu sync.Mutex
sendMu sync.Mutex
buffer []Result // 最近收到的未确认结果(最多保留 20 条)
seq int64
cancel context.CancelFunc
}
func NewManager(cfg TighteningConfig) *Manager {
return &Manager{cfg: cfg, buffer: make([]Result, 0, 20)}
}
// Latest 返回最近未确认的拧紧结果(前端轮询预填录入框)。
func (m *Manager) Latest() []Result {
m.mu.Lock()
defer m.mu.Unlock()
out := make([]Result, 0, len(m.buffer))
for _, r := range m.buffer {
if !r.Consumed {
out = append(out, r)
}
}
return out
}
// Consume 标记某条结果为已确认(操作工点「完成」后调用,避免重复上报同一缓冲项)。
func (m *Manager) Consume(id int64) {
m.mu.Lock()
defer m.mu.Unlock()
for i := range m.buffer {
if m.buffer[i].ID == id {
m.buffer[i].Consumed = true
}
}
}
// Enabled 是否已启用 OP 接入。
func (m *Manager) Enabled() bool { return m.cfg.Enable }
// Run 长连接主循环:断线指数退避重连。Enable=false 时直接返回(仍走人工录入)。
func (m *Manager) Run(ctx context.Context) {
if !m.cfg.Enable {
logx.Info("拧紧枪 OP 接入未启用(配置 Tightening.Enable=false):仍走人工录入拧紧值")
return
}
runCtx, cancel := context.WithCancel(ctx)
m.cancel = cancel
defer cancel()
backoff := time.Second
for {
select {
case <-runCtx.Done():
return
default:
}
conn, err := net.DialTimeout("tcp", m.cfg.ControllerAddr, 5*time.Second)
if err != nil {
logx.Errorf("拧紧控制器连接失败 %s: %v,%s 后重连", m.cfg.ControllerAddr, err, backoff)
if !sleepCtx(runCtx, backoff) {
return
}
backoff = minDur(backoff*2, 30*time.Second)
continue
}
logx.Infof("已连接拧紧控制器 %s", m.cfg.ControllerAddr)
backoff = time.Second
m.loop(runCtx, conn)
conn.Close()
logx.Infof("拧紧控制器连接断开,%s 后重连", backoff)
if !sleepCtx(runCtx, backoff) {
return
}
backoff = minDur(backoff*2, 30*time.Second)
}
}
// loop 单次连接内的处理:握手 → 订阅 → 心跳 + 持续接收。
func (m *Manager) loop(ctx context.Context, conn net.Conn) {
reader := bufio.NewReader(conn)
if err := conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
logx.Errorf("拧紧控制器设置握手超时失败: %v", err)
return
}
if err := m.handshake(reader, conn); err != nil {
logx.Errorf("拧紧控制器握手失败: %v", err)
return
}
if err := m.subscribe(reader, conn); err != nil {
logx.Errorf("拧紧结果订阅失败: %v", err)
return
}
// 握手/订阅完成,后续靠心跳保活,清除读超时
_ = conn.SetDeadline(time.Time{})
m.readLoop(ctx, conn, reader)
}
// handshake 发送 MID 0001(通信开始请求),期望 MID 0002(确认)/0004(拒绝)。
func (m *Manager) handshake(reader *bufio.Reader, conn net.Conn) error {
if err := m.send(conn, "0001", "001", ""); err != nil {
return err
}
f, err := readFrame(reader)
if err != nil {
return err
}
mid := f.mid
switch mid {
case "0002":
return nil
case "0003", "0004":
return fmt.Errorf("控制器拒绝通信开始 MID=%s", mid)
default:
return fmt.Errorf("握手收到非预期 MID=%s", mid)
}
}
// subscribe 发送 MID 0060(订阅拧紧结果,类型 0001),期望 MID 0005(确认)/0006(拒绝)。
// 注意:不订阅拧紧曲线(MID 0900/0901)——曲线不落地(用户口径);如需调试,改为订阅 + 仅日志。
func (m *Manager) subscribe(reader *bufio.Reader, conn net.Conn) error {
if err := m.send(conn, "0060", "001", "0001"); err != nil {
return err
}
f, err := readFrame(reader)
if err != nil {
return err
}
mid := f.mid
switch mid {
case "0005":
return nil
case "0006":
return fmt.Errorf("控制器拒绝订阅 MID=0006")
default:
return fmt.Errorf("订阅收到非预期 MID=%s", mid)
}
}
// readLoop 持续接收控制器报文:拧紧结果 → 暂存;心跳 → 回 ack。
func (m *Manager) readLoop(ctx context.Context, conn net.Conn, reader *bufio.Reader) {
hb := time.NewTicker(time.Duration(m.cfg.HeartbeatSec) * time.Second)
defer hb.Stop()
for {
select {
case <-ctx.Done():
return
case <-hb.C:
_ = m.send(conn, "9999", "001", "")
default:
f, err := readFrame(reader)
if err != nil {
if ctx.Err() != nil {
return
}
logx.Errorf("拧紧控制器读取断开: %v", err)
return
}
m.handleMessage(conn, f)
}
}
}
// handleMessage 处理一条收到的报文。
func (m *Manager) handleMessage(conn net.Conn, f frame) {
switch f.mid {
case "0061", "0062":
if r := parseTighteningResult(f); r != nil {
m.push(r)
logx.Infof("拧紧结果(OP MID %s): 扭矩=%.1f 角度=%.0f 结果=%s", f.mid, r.Torque, r.Angle, r.Result)
}
// NoAck=0 时控制器要求回确认
_ = m.send(conn, "0005", f.rev, f.mid)
case "9999":
_ = m.send(conn, "9999", f.rev, "")
case "0002", "0003", "0004", "0005", "0006":
// 握手/订阅相关,已在同步读路径处理
case "0900", "0901":
// 拧紧曲线(用户口径 2026-10-14:仅记录日志即可)。本客户端不订阅曲线(仅订阅 MID 0060 结果);
// 若控制器主动推送(罕见),收到即记一行日志,不解析、不落库。
// 曲线不落地;如需调试,改为订阅 + 仅日志。
logx.Infof("curve received (OP MID %s, %d 字节) —— 曲线仅记日志不解析不落库", f.mid, len(f.data))
default:
logx.Infof("拧紧控制器未处理 MID=%s", f.mid)
}
}
func (m *Manager) push(r *Result) {
m.mu.Lock()
defer m.mu.Unlock()
m.seq++
r.ID = m.seq
m.buffer = append(m.buffer, *r)
if len(m.buffer) > 20 {
m.buffer = m.buffer[len(m.buffer)-20:]
}
}
// send 发送一条 Open Protocol 报文(线程安全)。
func (m *Manager) send(conn net.Conn, mid, rev, data string) error {
header := padLeft(mid, 4, '0') + padLeft(rev, 3, '0') + "0" +
padLeft(m.cfg.StationID, 4, '0') + "00" +
padLeft(m.cfg.CellID, 2, '0') + padLeft(m.cfg.ChannelID, 2, '0') + padLeft(m.cfg.OperatorID, 2, '0')
body := header + data
length := len(body) + 1 // + ETX
msg := make([]byte, 0, 6+len(body)+1)
msg = append(msg, stx)
msg = append(msg, []byte(fmt.Sprintf("%04d", length))...)
msg = append(msg, []byte(body)...)
msg = append(msg, etx)
m.sendMu.Lock()
defer m.sendMu.Unlock()
_, err := conn.Write(msg)
return err
}
// ---------- 报文解析 ----------
type frame struct {
mid string
rev string
data string
}
// readFrame 从 reader 读取一个完整 STX...ETX 帧并解析。
func readFrame(reader *bufio.Reader) (frame, error) {
var buf []byte
for {
b, err := reader.ReadByte()
if err != nil {
return frame{}, err
}
if b == stx {
buf = []byte{b}
} else if b == etx {
buf = append(buf, b)
return parseFrame(buf)
} else if buf != nil {
buf = append(buf, b)
}
}
}
func parseFrame(raw []byte) (frame, error) {
if len(raw) < 2 || raw[0] != stx || raw[len(raw)-1] != etx {
return frame{}, fmt.Errorf("非法帧")
}
inner := raw[1 : len(raw)-1] // 去掉 STX/ETX
if len(inner) < 24 {
return frame{}, fmt.Errorf("帧过短")
}
header := inner[4:24] // 头部 20 字节
data := inner[24:] // 数据
mid := strings.TrimRight(string(header[0:4]), " \x00")
rev := strings.TrimRight(string(header[4:7]), " \x00")
dataStr := strings.TrimRight(string(data), " \x00")
return frame{mid: mid, rev: rev, data: dataStr}, nil
}
// parseTighteningResult 从 MID 0061/0062 数据解析拧紧结果。
// 0062 rev1:扭矩(6) + 角度(6) + 结果(2);0061 rev1:仅结果(2);高版本 0061 也含扭矩/角度。
func parseTighteningResult(f frame) *Result {
r := &Result{RawMid: f.mid, ReceivedAt: time.Now().UnixMilli()}
data := strings.TrimRight(f.data, " \x00")
if len(data) >= 14 {
r.Torque = parseFixed(data[0:6])
r.Angle = parseFixed(data[6:12])
r.Result = normResult(data[12:14])
} else if len(data) >= 2 {
r.Result = normResult(data[0:2])
}
if r.Result == "" {
r.Result = "OK"
}
return r
}
func parseFixed(s string) float64 {
s = strings.TrimSpace(strings.Trim(s, "\x00"))
v, _ := strconv.ParseFloat(s, 64)
return v
}
func normResult(s string) string {
s = strings.TrimSpace(strings.Trim(s, "\x00"))
switch s {
case "01":
return "OK"
case "02":
return "NG"
default:
return strings.ToUpper(s)
}
}
// ---------- 工具 ----------
func padLeft(s string, width int, pad rune) string {
if len(s) >= width {
return s[len(s)-width:]
}
return strings.Repeat(string(pad), width-len(s)) + s
}
func minDur(a, b time.Duration) time.Duration {
if a < b {
return a
}
return b
}
func sleepCtx(ctx context.Context, d time.Duration) bool {
t := time.NewTimer(d)
defer t.Stop()
select {
case <-ctx.Done():
return false
case <-t.C:
return true
}
}