企业官网建设流程全解析

适用对象：需要与三菱 Q/L/FX5U 等系列 PLC 做以太网直连采集的开发者（CNC 设备直连、产线数据采集、边缘网关）。 本文以QnA 兼容 3E 帧（二进制）为主线，给出帧级协议说明与 C++/Go 双语言完整可编译示例，并整理 20+ 条实战踩坑记录。 协议细节以三菱官方《MC 协议参考手册》（Q 系列：SH-080356；FX5U/iQ-F：JY997D56201）为准，本文表项已与多个现场抓包/工业驱动实现交叉核对。

1. 背景与定位

1.1 三菱 PLC 通信方式全景

三菱 MELSEC 系列 PLC 对外通信主要有三条路线：

MC 协议是三菱官方为外部设备（上位机）访问 PLC CPU 制定的通信协议，支持 QnA 兼容 3E/3C/4C 帧、4E 帧，以及新一代 SLMP（Seamless Message Protocol）帧。以太网场景下最常见的是QnA 兼容 3E 帧（二进制，TCP 承载），这也是本文的主线；FX5U / iQ-R 等新机型在 QnA 兼容 3E 帧基础上还提供 SLMP 新帧（设备头 5 字节，见 2.5 节与坑点 #5）。

1.2 适用场景

• CNC 设备直连采集（三菱 M80/M70、iQ-R 系列 CNC 控制器开放 MC 协议口）
• Q/L/FX5U PLC 的 D 寄存器、M 位元件、特殊寄存器（SM/SD）实时采集
• 边缘网关：PLC 点位 → MC 协议 → 网关 → Kafka/MQTT → 时序库

2. 协议全景：3E 帧格式详解（API 说明）

2.1 传输模型总览

• 承载：TCP（默认端口 2000，可在 GX Works3 / GX Developer 中配置，常见 1025/4999）
• 帧形态：无帧头、无帧尾、无校验和的裸 TCP 载荷（长度字段自带定界）
• 请求/响应副头部不同：请求帧副头部固定 0x5000，响应帧副头部固定 0xD000（字节序见 2.4）
• 多字节字段一律小端（LSB first）：这是与网络字节序直觉最大的冲突点，也是最多人踩的坑（见坑点 #1）

2.2 请求帧字段表（QnA 兼容 3E 帧，二进制）

请求数据长度计算示例（批量读 D100 起 10 点）：监视定时器 2 + 命令 2 + 子命令 2 + 软元件头 4 + 点数 2 =12 字节，即 0x000C，发送字节 0C 00。

2.3 响应帧字段表

响应帧读取流程：先读固定 9 字节头（副头 2+网络 1+PC 1+IO 2+站 1+长度 2），解析长度 L 后再读 L 字节，其中前 2 字节是结束代码、其余为数据区。

2.4 字节序规则（核心中的核心）

• 二进制 3E 帧：所有多字节字段按LSB first（低字节在前）发送：命令 0x0401 → 字节 01 04；长度 0x000C → 0C 00；软元件代码 0x00A8 → A8；设备编号 0x0064 → 64 00 00；点数 0x000A → 0A 00。
• 数据区：字数据 16 位小端（读回 0x1234 → 数据字节 34 12）；32 位浮点/整数占 2 个字，低字在前；64 位占 4 个字。
• ASCII 帧（4E）：所有字段用 ASCII 十六进制字符表示，MSB first（字符顺序即十六进制书写顺序），且数据区字符每字 4 字符（高字节字符在前）。两种帧的字段值方向恰好相反，混用必然出错（坑点 #8）。

2.5 软元件（设备）体系与代码表

MC 协议按「软元件代码 + 软元件编号」寻址，同一编号 0 可以同时是 D0 / M0 / X0，全靠代码区分。

QnA 兼容 3E 帧常用软元件代码（二进制帧，1 字节）：

设备代码因 CPU 系列而异（尤其 T/C 定时器计数器、FX 系列），现场联调以对应手册与抓包为准。

设备头格式两代差异（重要）：

现场最常见两种实现都在运行：老式 QnA 3E 驱动普遍用 4 字节头，pymcprotocol 等新库常用 5 字节头。联调失败时优先核对设备头长度与顺序（坑点 #5），用 Wireshark 抓包对照官方手册即可快速定位。

2.6 命令 / 子命令表

命令号随系列有差异（QnA 兼容 3E 帧与 L/FX 的 SLMP 表不完全一致），以对应 CPU 手册为准。批量写命令是 0x1401 而不是 0x0402（坑点 #6）。

2.7 常用报文构造示例

批量读 D100 起 10 字（请求，共 9+12=21 字节）：

50 00 | 00 | FF | FF 03 | 00 | 0C 00 | 10 00 | 01 04 | 00 00 | 64 00 00 A8 | 0A 00 副头部 网络 PC IO 站 长度 定时器 命令 子命令 编号3B+代码 点数

响应（正常）：

D0 00 | 00 | FF | FF 03 | 00 | 16 00 | 00 00 | [20 字节数据，每字小端] 副头部 网络 PC IO 站 长度 结束码 D100..D109 共 10 字

响应长度 0x0016 = 结束代码 2 字节 + 数据 20 字节。

批量写 D200 写 1 字 0x0102（=258）：

50 00 | 00 | FF | FF 03 | 00 | 0E 00 | 10 00 | 01 14 | 00 00 | C8 00 00 A8 | 01 00 | 02 01 └─ 数据 0x0102 小端

2.8 ASCII 帧（4E 帧）简要对比

• 所有字段为 ASCII 十六进制字符：副头部字符 "5000" / "D000"，长度字段表示后续字符个数（不是字节数）。
• 设备头字符顺序：设备代码 2 字符 + 设备编号 6 字符（MSB first），与二进制帧顺序相反。
• 数据区每字 4 字符（如 "3412" 表示 0x1234）。
• 体积约为二进制的 2 倍，带宽紧张/点数多时优先二进制帧。

2.9 错误码（结束代码）速查

错误码按系列略有差异，完整表以官方手册附录为准。写程序时务必把结束代码打印成十六进制，否则 C05F 被当成 49247 很难排查。

3. 环境准备与联调工具

3.1 PLC 侧设置（GX Works3 / GX Developer）

1. 给 PLC 分配固定 IP（如 192.168.1.10，子网掩码 255.255.255.0）。
2. 内置以太网端口 → 通信数据代码：二进制（Binary）；帧类型：QnA 兼容 3E 帧（FX5U 默认也是此帧）。
3. 打开 MC 协议端口：默认 TCP2000；记下端口号。
4. 简单场景无需设置站号（默认网络 0、PC 号 255、IO 号 03FF、站号 0）。

3.2 PC 侧工具

4. 详细使用说明（实战代码）

4.1 Go 完整实现（主推，贴合 Go 采集网关场景）

package main import ( "encoding/binary" "errors" "fmt" "io" "math" "net" "sync" "time" ) // ---------- 软元件代码（QnA 兼容 3E 帧，1 字节） ---------- const ( DevX = 0x9C // 输入继电器 X DevY = 0x9D // 输出继电器 Y DevM = 0x90 // 内部继电器 M DevS = 0x98 // 步进继电器 S DevL = 0x92 // 锁存继电器 L DevF = 0x93 // 报警器 F DevV = 0x94 // 边沿继电器 V DevB = 0xA0 // 链接继电器 B DevD = 0xA8 // 数据寄存器 D DevW = 0xB4 // 链接寄存器 W DevR = 0xAF // 文件寄存器 R DevSM = 0x91 // 特殊继电器 SM DevSD = 0xA9 // 特殊寄存器 SD DevTN = 0xC2 // 定时器当前值 TN DevCN = 0xC5 // 计数器当前值 CN ) // ---------- 命令 / 子命令 ---------- const ( CmdBatchRead = 0x0401 CmdBatchWrite = 0x1401 CmdRandomRead = 0x0403 CmdRandomWrite = 0x1402 SubWord = 0x0000 SubBit = 0x0001 ) // Client 三菱 MC 协议 QnA 兼容 3E 帧客户端（4 字节设备头） type Client struct { addr string conn net.Conn timeout time.Duration timer uint16 // 监视定时器，单位 250ms mu sync.Mutex } func NewClient(addr string, timeout time.Duration) *Client { return &Client{addr: addr, timeout: timeout, timer: 0x0010} // 4 秒 } func (c *Client) Connect() error { conn, err := net.DialTimeout("tcp", c.addr, c.timeout) if err != nil { return err } c.conn = conn return nil } func (c *Client) Close() error { if c.conn != nil { return c.conn.Close() } return nil } // buildFrame 构造请求帧（设备头：编号 3 字节小端 + 代码 1 字节） func (c *Client) buildFrame(cmd, subcmd uint16, devCode byte, devNo uint32, points uint16, data []byte) []byte { buf := make([]byte, 0, 64) buf = append(buf, 0x50, 0x00) // 副头部 0x5000 buf = append(buf, 0x00, 0xFF, 0xFF, 0x03, 0x00) // 网络 0 / PC FF / IO 03FF / 站 0 lenPos := len(buf) buf = append(buf, 0, 0) // 请求数据长度（占位） buf = binary.LittleEndian.AppendUint16(buf, c.timer) // 监视定时器 buf = binary.LittleEndian.AppendUint16(buf, cmd) // 命令 buf = binary.LittleEndian.AppendUint16(buf, subcmd) // 子命令 buf = append(buf, byte(devNo), byte(devNo>>8), byte(devNo>>16)) // 设备编号 3 字节小端 buf = append(buf, devCode) // 设备代码 1 字节 buf = binary.LittleEndian.AppendUint16(buf, points) // 点数 buf = append(buf, data...) // 写数据（读命令为空） l := len(buf) - lenPos - 2 // 回填长度（从定时器起） buf[lenPos], buf[lenPos+1] = byte(l), byte(l>>8) return buf } func (c *Client) writeAll(p []byte) error { c.conn.SetWriteDeadline(time.Now().Add(c.timeout)) for len(p) > 0 { n, err := c.conn.Write(p) if err != nil { return err } p = p[n:] } return nil } // readResponse 读取并解析响应：返回结束代码与数据区 func (c *Client) readResponse() (uint16, []byte, error) { c.conn.SetReadDeadline(time.Now().Add(c.timeout)) head := make([]byte, 9) if _, err := io.ReadFull(c.conn, head); err != nil { return 0, nil, err } if head[0] != 0xD0 || head[1] != 0x00 { return 0, nil, errors.New("invalid response header") } length := binary.LittleEndian.Uint16(head[7:9]) // 响应数据长度 = 结束码2 + 数据N body := make([]byte, length) if _, err := io.ReadFull(c.conn, body); err != nil { return 0, nil, err } return binary.LittleEndian.Uint16(body[0:2]), body[2:], nil } // exec 统一执行一帧请求（带互斥，避免多 goroutine 帧交错） func (c *Client) exec(cmd, subcmd uint16, devCode byte, devNo uint32, points uint16, data []byte) ([]byte, error) { c.mu.Lock() defer c.mu.Unlock() if err := c.writeAll(c.buildFrame(cmd, subcmd, devCode, devNo, points, data)); err != nil { return nil, err } endCode, resp, err := c.readResponse() if err != nil { return nil, err } if endCode != 0 { return nil, fmt.Errorf("PLC error 0x%04X", endCode) } return resp, nil } // ---------- 高层 API ---------- // ReadWords 批量读字元件（D/W/R/SD 等） func (c *Client) ReadWords(devCode byte, devNo uint32, points uint16) ([]uint16, error) { resp, err := c.exec(CmdBatchRead, SubWord, devCode, devNo, points, nil) if err != nil { return nil, err } if len(resp) != int(points)*2 { return nil, fmt.Errorf("unexpected resp len %d", len(resp)) } out := make([]uint16, points) for i := range out { out[i] = binary.LittleEndian.Uint16(resp[i*2:]) } return out, nil } // WriteWords 批量写字元件，data 每元素对应一个字 func (c *Client) WriteWords(devCode byte, devNo uint32, vals []uint16) error { data := make([]byte, len(vals)*2) for i, v := range vals { binary.LittleEndian.PutUint16(data[i*2:], v) } _, err := c.exec(CmdBatchWrite, SubWord, devCode, devNo, uint16(len(vals)), data) return err } // ReadBits 批量读位元件（X/Y/M/L 等），返回每点 bool func (c *Client) ReadBits(devCode byte, devNo uint32, points uint16) ([]bool, error) { resp, err := c.exec(CmdBatchRead, SubBit, devCode, devNo, points, nil) if err != nil { return nil, err } if len(resp) != int(points) { return nil, fmt.Errorf("unexpected resp len %d", len(resp)) } out := make([]bool, points) for i, b := range resp { out[i] = b != 0 } return out, nil } // WriteBits 批量写位元件，每点 0/1 func (c *Client) WriteBits(devCode byte, devNo uint32, vals []bool) error { data := make([]byte, len(vals)) for i, v := range vals { if v { data[i] = 1 } } _, err := c.exec(CmdBatchWrite, SubBit, devCode, devNo, uint16(len(vals)), data) return err } // ReadFloat32 读 32 位浮点（占 2 个连续字，低字在前，IEEE754 小端） func (c *Client) ReadFloat32(devCode byte, devNo uint32) (float32, error) { words, err := c.ReadWords(devCode, devNo, 2) if err != nil { return 0, err } b := []byte{byte(words[0]), byte(words[0] >> 8), byte(words[1]), byte(words[1] >> 8)} return math.Float32frombits(binary.LittleEndian.Uint32(b)), nil } // WriteFloat32 写 32 位浮点 func (c *Client) WriteFloat32(devCode byte, devNo uint32, v float32) error { b := make([]byte, 4) binary.LittleEndian.PutUint32(b, math.Float32bits(v)) vals := []uint16{binary.LittleEndian.Uint16(b[0:2]), binary.LittleEndian.Uint16(b[2:4])} return c.WriteWords(devCode, devNo, vals) }

使用示例

func main() { c := NewClient("192.168.1.10:2000", 3*time.Second) if err := c.Connect(); err != nil { panic(err) } defer c.Close() // 读 D100~D109 十个数据寄存器 words, err := c.ReadWords(DevD, 100, 10) if err != nil { panic(err) } fmt.Println("D100..D109 =", words) // 读 M0~M7 八个内部继电器 bits, err := c.ReadBits(DevM, 0, 8) if err != nil { panic(err) } fmt.Println("M0..M7 =", bits) // 写 D200 = 258，D201 = 0x1234 if err := c.WriteWords(DevD, 200, []uint16{258, 0x1234}); err != nil { panic(err) } }

4.2 C++ 最小实现（WinSock / POSIX 通用思路）

#include <cstdint> #include <cstring> #include <iostream> #include <stdexcept> #include <vector> #ifdef _WIN32 #include <winsock2.h> #pragma comment(lib, "ws2_32.lib") #else #include <arpa/inet.h> #include <sys/socket.h> #include <unistd.h> #endif // 软元件代码 enum DevCode : uint8_t { D = 0xA8, M = 0x90, X = 0x9C, Y = 0x9D, SD = 0xA9, W = 0xB4 }; class MCClient { public: MCClient(const std::string& ip, uint16_t port, uint32_t timeoutMs = 3000) : ip_(ip), port_(port), timeoutMs_(timeoutMs), sock_(-1) {} ~MCClient() { close(); } void connect() { #ifdef _WIN32 WSADATA wsa; WSAStartup(MAKEWORD(2, 2), &wsa); #endif sock_ = ::socket(AF_INET, SOCK_STREAM, 0); sockaddr_in addr{}; addr.sin_family = AF_INET; addr.sin_port = htons(port_); inet_pton(AF_INET, ip_.c_str(), &addr.sin_addr); if (::connect(sock_, (sockaddr*)&addr, sizeof(addr)) != 0) { throw std::runtime_error("connect failed"); } } void close() { if (sock_ >= 0) { #ifdef _WIN32 closesocket(sock_); #else ::close(sock_); #endif sock_ = -1; } } // 批量读字，返回每字 16 位 std::vector<uint16_t> readWords(uint8_t devCode, uint32_t devNo, uint16_t points) { std::vector<uint8_t> frame = buildFrame(0x0401, 0x0000, devCode, devNo, points, {}); sendAll(frame); auto resp = readResponse(); if (resp.size() != points * 2) throw std::runtime_error("resp length mismatch"); std::vector<uint16_t> out(points); for (size_t i = 0; i < points; ++i) { out[i] = (uint16_t)resp[i*2] | ((uint16_t)resp[i*2+1] << 8); } return out; } private: std::vector<uint8_t> buildFrame(uint16_t cmd, uint16_t subcmd, uint8_t devCode, uint32_t devNo, uint16_t points, const std::vector<uint8_t>& data) { std::vector<uint8_t> f; auto push16 = [&](uint16_t v) { f.push_back(v & 0xFF); f.push_back(v >> 8); }; // LSB first f.push_back(0x50); f.push_back(0x00); // 副头部 f.insert(f.end(), {0x00, 0xFF, 0xFF, 0x03, 0x00}); // 网络/PC/IO/站 size_t lenPos = f.size(); f.push_back(0); f.push_back(0); // 长度占位 push16(0x0010); // 监视定时器 4s push16(cmd); push16(subcmd); f.push_back(devNo & 0xFF); f.push_back((devNo >> 8) & 0xFF); f.push_back((devNo >> 16) & 0xFF); f.push_back(devCode); // 设备代码 1 字节 push16(points); f.insert(f.end(), data.begin(), data.end()); uint16_t len = (uint16_t)(f.size() - lenPos - 2); // 从定时器起 f[lenPos] = len & 0xFF; f[lenPos + 1] = len >> 8; return f; } void sendAll(const std::vector<uint8_t>& buf) { size_t sent = 0; while (sent < buf.size()) { int n = ::send(sock_, (const char*)buf.data() + sent, (int)(buf.size() - sent), 0); if (n <= 0) throw std::runtime_error("send failed"); sent += n; } } std::vector<uint8_t> readResponse() { uint8_t head[9]; recvAll(head, 9); if (head[0] != 0xD0 || head[1] != 0x00) throw std::runtime_error("bad resp header"); uint16_t len = (uint16_t)head[7] | ((uint16_t)head[8] << 8); std::vector<uint8_t> body(len); recvAll(body.data(), len); uint16_t endCode = (uint16_t)body[0] | ((uint16_t)body[1] << 8); if (endCode != 0) throw std::runtime_error("PLC error 0x" + hex(endCode)); return std::vector<uint8_t>(body.begin() + 2, body.end()); } void recvAll(uint8_t* p, size_t n) { size_t got = 0; while (got < n) { int r = ::recv(sock_, (char*)p + got, (int)(n - got), 0); if (r <= 0) throw std::runtime_error("recv failed"); got += r; } } static std::string hex(uint16_t v) { char b[8]; snprintf(b, sizeof(b), "%04X", v); return b; } std::string ip_; uint16_t port_; uint32_t timeoutMs_; int sock_; }; // 使用示例 // MCClient c("192.168.1.10", 2000); // c.connect(); // auto vals = c.readWords(D, 100, 10);

4.3 位元件与 32 位数据读写要点

• 位元件：批量读子命令 0x0001，响应每点 1 字节（0x00=OFF，0x01=ON）；写入同理。
• 32 位整数 / 浮点：占 2 个连续字。低地址字存低 16 位（小端），字节序与字序均为小端，Go 侧用 binary.LittleEndian 拼 4 字节即可，见 4.1 的 ReadFloat32。
• 64 位：占 4 个连续字，同样小端拼接。
• BCD 数据：三菱某些元件（如部分 FX 系列地址、时钟 D 区）按 BCD 编码，读取后需自行 BCD→二进制转换（(v & 0xF0) >> 4 * 10 + (v & 0x0F) 等），这是容易算错的一类数据（坑点 #18）。

4.4 采集工程实践（贴合数采项目）

1. 连接管理：每条链路一个 TCP 连接 + 一个采集 goroutine，用 sync.Mutex 串行化帧收发（帧间不允许并发交错，见坑点 #20）。断线后按指数退避重连（1s→2s→4s…上限 30s），并复位监视定时器。
2. 批量最大化：D/W 等连续点位尽量一次读满（字上限 960 点），把 100 次 1 点请求合并成 1 次 100 点请求，吞吐可提升一个数量级；不连续点位用 0x0403 随机读一次打包（上限约 192 点），比逐点批量读更快。
3. 点位表驱动：把「设备代码+起始号+点数+缩放系数」做成配置文件，采集循环按表轮询，新增点位不改代码。
4. 链路落库：采集值 → 打时间戳 → 写 Kafka（kafka-go / librdkafka）→ 消费端落 TDengine；PLC 侧一次批量读的结果作为一条消息体，减少消息量与延迟。
5. 写操作安全：写命令加白名单地址校验 + 写前读回确认；生产环境尽量只读（RUN 状态下部分系列写被禁止，会返回 0xC10F）。

5. 常错点 / 坑（20+ 条实战记录）

帧格式类

1. 字节序搞反（最高频）：二进制 3E 帧所有多字节字段是小端（命令 0x0401 发 01 04）。拿网络字节序大端拼帧，PLC 直接回 0xC05D（命令错误）或 0xC05E（软元件类型错误）。
2. 请求长度字段算错：请求数据长度是从监视定时器字段开始算到请求数据末尾，不含长度字段本身、也不含前面 7 字节头部。算多了/算少了都会导致 0xC056/C057 长度错误。响应长度则是从结束代码开始算（= 2 + 数据）。
3. 副头部写错方向：请求副头部是 0x5000，响应才是 0xD000。不少网文示例把请求头也写成 D0 00，照抄后永远读不到正常响应。正确的请求帧前 9 字节应为 50 00 00 FF FF 03 00 0C 00（读取 10 点时）。
4. 把 4E（ASCII）和 3E（二进制）字段混用：ASCII 帧字段是字符、MSB first、长度单位是字符数；二进制帧是字节、LSB first。PLC 侧通信数据码设置成「二进制」却发 ASCII 帧（或反之），行为不可预测。用 Wireshark 一眼可辨。
5. 设备头格式不匹配（QnA 4 字节 vs SLMP 5 字节）：QnA 兼容 3E 帧设备头是「编号 3 字节 + 代码 1 字节」（4 字节）；SLMP 新帧是「代码 2 字节 + 编号 3 字节」（5 字节）。两者编号和代码的顺序还相反。用错后典型现象：读到的值全部错位或报 0xC05E 软元件类型错误。现场用官方手册 + 抓包对照确认。
6. 批量写命令写成 0x0402：批量写是 0x1401（字）/ 0x1401+子命令1（位），0x0402 不是标准批量写命令。很多博客示例写错，照抄后 PLC 回 0xC05D。
7. 监视定时器设为 0 或过小：监视定时器单位 250ms，设为 0 时部分系列按默认值（约 5s）处理，但设得比 PLC 实际响应时间还小会提前报 0xC120 时间限制错误。批量写/远程 STOP 等耗时操作建议 4~10s。
8. 响应长度解析位置错：响应固定头是 9 字节（副头 2+网络 1+PC 1+IO 2+站 1+长度 2），很多人按 7 字节读，把结束代码当成长度解析，数据全错。正确流程：读 9 字节 → 解析长度 → 再读 N 字节 → 前 2 字节结束码。

寻址类

1. 软元件编号进制混用：帧中软元件编号按 16 进制编码。D100 → 编号 100 → 0x0064（发 64 00 00）。有人直接填 100 的十六进制显示习惯或直接写 BCD，读出的地址完全不对。
2. X/Y 编号进制随系列变化：Q/L 系列 X/Y 用十六进制编号（X0X1FFF），FX 系列 X/Y 用八进制编号（X0X7、X10~X17…）。FX 系列要把八进制地址的数字值当十进制转十六进制编码（如 X20 八进制 → 编号 20 → 0x14），编码错误会读到错误点位或越界。
3. 位元件当字读 / 字元件当位读：子命令 0x0000=字单位、0x0001=位单位。M 等位元件用字单位读会得到「16 点打包」的位模式（每点=16 位），与直觉不符；D 等字元件用位单位读则直接报错或返回 1 字节/点。
4. 点数量级错误：批量读字元件每点是2 字节，响应长度 = 点数×2；位元件每点 1 字节。按「点数=字节数」解析会把数据整体错位。还有位元件批量读上限按「位」计，超过上限回 0xC05F。
5. 随机读写点数上限记错：随机读最多约 192 点、随机写约 64192 点（按系列），超过上限报 0xC05F。批量读写字元件上限 960 点、位元件上限 35847168 点（按帧类型/系列）。上限不满足时拆分请求。

数据语义类

1. 浮点/32 位数据字节序与字序搞错：32 位浮点占 2 个字，低地址字在前（小端），4 字节整体也是小端。按「高字在前」或按大端拼字节，读出的 float 是天文数字或 NaN。64 位同理。
2. BCD 数据未转换：PLC 时钟、部分计数器/地址参数默认 BCD 编码（如 0x25 表示 25 而不是 37）。采集 D 区时钟类数据不做 BCD→二进制转换，数值全部翻车。判断依据：PLC 侧数据格式设置与数据实际含义。
3. PLC 停机/RUN 状态与写权限：CPU 处于 STOP/初始化时读会回 0xC105 或 0xC10F；RUN 状态下部分系列禁止写，写失败要区分「协议错」和「状态错」，不要盲目重试写操作。
4. 读回值与 PLC 监视不一致：先确认你读的地址类型（D 是字、M 是位）与 PLC 侧软元件监视窗口一致；再确认采集程序里有没有把位当字、把 16 位当 32 位、漏掉缩放系数（工程值 = 原始值 × 系数 + 偏移）。

工程实现类

1. 多 goroutine/线程并发收发不互斥：TCP 上连续两个请求的响应是按顺序返回的，并发写帧会导致响应错配（A 请求的响应被 B 解析）。必须串行化整帧收发（互斥锁包裹 write+read 全过程），或每个连接独占一个 goroutine。
2. io.ReadFull 缺失 / recv 半包：TCP 是字节流，一次 recv 可能只收到半个响应帧。必须循环读满「9 字节头 + 长度字段声明的 N 字节」，用 io.ReadFull/recvAll 而不是单次 Read/recv。
3. 连接断开不重连：PLC 重启、网线抖动、CPU 模块复位都会断开 TCP。采集程序要监听错误并指数退避重连，否则静默丢数。重连后建议重读一次全量点位做基线对齐。
4. 不检查结束代码就解析数据：结束代码非 0 时响应数据区可能为空或为错误信息，直接按正常数据解析会产生「幽灵数据」。务必先判断 endCode != 0 并返回带错误码的错误。
5. 凭感觉调帧不抓包：MC 协议字节级细节多，肉眼排错效率极低。正确姿势：先 Wireshark 抓一帧官方工具（GX Works3 监视/网络调试助手）发出的正常帧，逐字节对照自己代码的帧，差异即 bug。
6. 端口号写错：默认 TCP 2000，但很多项目把 PLC 端口改成 1025/4999 或按模块不同。连不上先 ping + 测试端口连通性（Test-NetConnection / nc）。
7. ASCII 帧长度单位误解：若用 4E 帧，长度字段是后续字符数（一个字节十六进制占 2 字符），不是字节数，差一倍。二进制帧才是字节数。

6. 性能与实践建议

点位规划建议：把高频点位（≤100ms）与低频点位（1s~1min）分不同批次轮询，避免低频慢点拖累高频链路；多块批量读（0x0406）在点数多且分段时最省。

7. FAQ 速查

Q1：连不上 PLC 常见原因？先 ping IP；再用 Test-NetConnection <ip> -Port 2000 测端口；确认 GX Works3 里 MC 协议端口已打开、通信数据码与你的帧类型一致（二进制 3E ↔ 二进制）。

Q2：能 ping 通但读不到数据？大概率帧格式问题：字节序、请求长度、设备头格式（4/5 字节）、软元件代码。抓包对照官方工具帧排查。

Q3：读 D100 得到 0xFFFF / 0x0000 正常吗？可能是未初始化或该地址无数据（返回 0），也可能是地址或类型错（读错元件）。用 GX Works3 软元件监视核对同一地址。

Q4：MC 协议一次最多读多少个点？字批量读 ≤960 点，位批量读 3584~7168 点（按系列/帧类型），随机读 ≤192 点。超过需拆分。

Q5：读浮点数据乱码？检查字序：32 位浮点占 2 个字、低字在前、整体小端；确认 PLC 侧该区域确实是 float 类型而非整数/BCD。

Q6：写操作返回 C10F 是什么？CPU 处于 RUN 且该系列 RUN 状态禁止写，或当前站无写权限。改到 STOP 或给对应系列开启 RUN 中写入（需 PLC 侧参数支持）。

Q7：必须用三菱官方 MX Component 吗？不是。MC 协议帧格式公开，自研 TCP 客户端完全可行（本文即例）。MX Component 适合快速出原型，但部署重、跨平台差；生产采集网关自研更轻。

Q8：FX5U 和 Q 系列帧一样吗？基本一致（都支持 QnA 兼容 3E 帧），但设备代码/命令号/点数上限有细微差异，部分功能需 SLMP 新帧（5 字节设备头）。以 FX5U 手册（JY997D56201）核对。

8. 总结

MC 协议（QnA 兼容 3E 帧）是三菱 PLC 以太网直连的事实标准：裸 TCP + 无校验和 + 全小端多字节字段 + 长度自定界。掌握五个要点即可稳定落地：

1. 帧结构：9 字节固定头 + 请求长度（从定时器起）/ 响应长度（从结束码起）；
2. 字节序：二进制帧多字节字段全部 LSB first，数据区字/双字同样小端；
3. 寻址：软元件代码 + 编号（16 进制编码），X/Y 进制随系列，设备头注意 QnA 4 字节 vs SLMP 5 字节；
4. 命令：批量读 0x0401 / 批量写 0x1401 / 随机读 0x0403 / 随机写 0x1402，子命令 0=字 1=位；
5. 工程：串行收发 + ReadFull + 结束码检查 + 断线重连 + 批量最大化 + 抓包验证。

这条链路与既有系列篇目自然衔接：Qt SerialPort（串口）/ libmodbus（Modbus 设备）→ MC 协议（三菱 PLC/CNC 直连）→ paho MQTT / librdkafka / kafka-go（传输缓冲）→ TDengine（时序落库）→ NumPy / Pandas / PyTorch / ONNX Runtime（分析与 AI），构成完整的工业数采技术栈。

9. 参考资料

• 三菱 MELSEC 通信协议参考手册（Q 系列：SH-080356；FX5U/iQ-F：JY997D56201）
• 三菱 GX Works3 / GX Developer 帮助文档（MC 协议设置、软元件监视）
• 各 PLC 型号 CPU 编程手册（软元件编号规则、点数上限）
• Wireshark 抓包实测（联调标准流程）