Files
bj_power/bj_power_mes/internal/plc/tcp.go
T
SunYF 9aaa768e6c feat(mes): AGV挂起动作引擎 + 智能跟车流转 + PLC快照缓存(2026-11-19 主控拍板)
一、AGV 挂起动作引擎(弃显式任务队列、弃并发硬拒)
- 新增 internal/logic/agv_pending.go:待发动作直接挂任务(pending_action + pending_since),
  CONTINUE_LIFT(举升完成→continueTask#1)/ WAIT_DROP_CONFIRM(人工确认放下→continueTask#2)
  / FREE_ROBOT(末组完成→freeRobot);系统动作超 60s 未触发转预警人工重试,绝不自动重发
- Client 新增 ContinueTask(RCS 2.1.2) / FreeRobot(3.1.2),仅点名释放指定车,禁止释放全部
- agv_task 增 pending_action/pending_since 字段,ent 重生成 + db.go 幂等迁移补丁 + migrateonce
- 回调按 B01/B02/C01 模板编排:业务流转到位即自动放行放下、回调自动放车;
  仅人工派车(MANUAL)挂 WAIT_DROP_CONFIRM;新增 /agv/confirm-drop、/agv/pending/retry
- 前端 AgvManual/Agv 确认放下、挂起重试按钮与等待提示联动

二、智能跟车 + 动态目标截断流转引擎
- 新增 internal/logic/flow_engine.go:事件驱动(报工/扫码),读 48 位物理快照,从下游往上游算,
  前方占用则动态截断到最近空闲缓存位;IN_TRANSIT 在途闭锁防重复下发,MW=0 才确认到位落台账;
  主线占用=台账 OR 传感器,工位 G 位只认台账;在途超 5s 落预警
- workpiece 增 flow_transit_mw/target/at 字段,ent 重生成 + 迁移补丁

三、PLC 读取优化与诊断
- 新增 internal/plc/snapshot_cache.go:2s TTL + singleflight + 写失效,合并 SSE/PLC监控/流转引擎
  的重复点位读取;tcp.go 读块重构、localip.go 多网卡、plcdiag 诊断工具、plc_monitor/logging 配套

四、文档与前端
- help.js 重写「工位下发」帮助:明确报工自动驱动流转 vs 下发路线码的定位、缺料/握手/撤回边界
- 案例.md 补充定稿说明;public/index.html 构建指纹更新
2026-11-19 23:08:46 +08:00

281 lines
10 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
// plcOpTimeout 单次 S7 网络操作的硬上限(拨号 + 一次读/写事务的收尾)。
// 2026-11-19 修正:原值 30s 与上层 plcHardCut 2.5s 严重错配——gos7 的 Send 用
// conn.SetDeadline(lastActivity+Timeout) 做读超时,30s 内不返回的读会把事务层
// 的串行闸一直占住;上层虽已 2.5s 硬切返回,底层 goroutine 仍在拨号/读,后续
// 每轮轮询全部堵在闸上 → 日志里成片 context deadline exceeded。现场实测正常
// 单次读 <50ms(诊断工具 17ms 建连),1.5s 已是极宽裕的容错,断电时也能Quick fail。
plcOpTimeout = 1500 * time.Millisecond
)
// s7Real 真实西门子 S7 客户端(gos7),持有一条长连接,断线惰性重连。
//
// 并发模型(2026-11-19 重构,修复 PLC 强制断链 / 重连风暴):
// - gos7 的 Client 用同一个 TCPClientHandler/conn + 自增事务号收发,并非并发安全:
// 两个 goroutine 同时在一条连接上做 AGReadMB,会出现请求-响应错配、读到半包、
// PLC 协议栈拒绝报文并主动 RST(日志里 "forcibly closed by the remote host")。
// - 因此连接建立 + 每一次读/写事务全程在 opMu 内串行执行,任何时刻只有一条 S7 事务在途。
// - 串行化后单事务耗时可控(<50ms),不会拖垮 3s 一轮的监控页快照 / 看板 SSE。
type s7Real struct {
c config.PlcConf
handler *gos7.TCPClientHandler
client gos7.Client
opMu sync.Mutex // 串行闸:连接 + 单次事务全程持有,保证 gos7 单连接不被并发访问
}
func newS7Real(c config.PlcConf) *s7Real {
h := gos7.NewTCPClientHandler(c.Host, c.Rack, c.Slot)
h.Timeout = plcOpTimeout
return &s7Real{c: c, handler: h}
}
// ensure 惰性连接 + 断线重连。调用方必须已持有 s.opMu。
// 用 ConnectContext 而非 Connect:gos7 的 Connect() 内部走 context.Background(),
// 拨号不可打断;带 ctx 后上层 plcHardCut 硬切能真正取消拨号,不留后台 goroutine。
func (s *s7Real) ensure(ctx context.Context) error {
if s.client != nil {
return nil
}
if err := s.handler.ConnectContext(ctx); err != nil {
return err
}
s.client = gos7.NewClient(s.handler)
return nil
}
// run 在串行闸内执行一条 S7 事务:确保连接 → 执行 fn → 出错即断链(下轮惰性重连)。
// 拨号阶段认 ctx(可被上层硬切取消);读/写事务阶段由 gos7 的 plcOpTimeout 兜底。
func (s *s7Real) run(ctx context.Context, fn func(gos7.Client) error) error {
s.opMu.Lock()
defer s.opMu.Unlock()
if err := s.ensure(ctx); err != nil {
return err
}
if err := fn(s.client); err != nil {
_ = s.handler.Close()
s.client = nil
return err
}
return nil
}
// readBlock 读取 48 位块(MB895..MB902)原始 8 字节。
func (s *s7Real) readBlock(ctx context.Context) ([]byte, error) {
buf := make([]byte, plcBlockBytes)
err := s.run(ctx, func(cl gos7.Client) error {
return cl.AGReadMB(plcBlockStartByte, plcBlockBytes, buf)
})
if err != nil {
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)
}
buf := make([]byte, length)
err := s.run(ctx, func(cl gos7.Client) error {
return cl.AGReadMB(byteOffset, length, buf)
})
if err != nil {
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 {
return s.run(ctx, func(cl gos7.Client) error {
return cl.AGWriteMB(byteOffset, len(data), data)
})
}