新增扫码中间件支持网络型扫码枪键盘注入,AGV 对接从 WMS 迁至 MES 统一管理;新增拧紧不合格人工处置与 PLC 对账机制,优化退库单关联与工位终端功能,同时清理旧 AGV 任务表,完善数据库与配置项。
378 lines
11 KiB
Go
378 lines
11 KiB
Go
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
|
||
}
|
||
}
|