diff --git a/.vitepress/zh.json b/.vitepress/zh.json
index 12c2e8b3..c5a45ad9 100644
--- a/.vitepress/zh.json
+++ b/.vitepress/zh.json
@@ -66,7 +66,7 @@
           "link": "cli/build.md"
         },
         {
-          "text": "JSON-RPC（MCAL-CAN）",
+          "text": "JSON-RPC (MCAL-CAN)",
           "link": "cli/rpc.md"
         }
       ]
@@ -206,7 +206,7 @@
           "link": "can_timer/readme.md"
         },
         {
-          "text": "NXP UDS Bootloader",
+          "text": "NXP UDS 引导加载程序",
           "link": "nxp_bootloader/readme.md"
         }
       ],
diff --git a/docs/zh/dev/releases_note.md b/docs/zh/dev/releases_note.md
index 3c8e8c0d..2dca728c 100644
--- a/docs/zh/dev/releases_note.md
+++ b/docs/zh/dev/releases_note.md
@@ -4,8 +4,8 @@
 
 自 v0.8.65 以来的变化：
 
-- [feat]: 新增 `ecb_cli rpc` JSON-RPC 2.0 服务，供 PC 版 MCAL-CAN（C）驱动使用
-- [feat]: 图形界面 JSON-RPC 网关 — EcuBus 运行时，外部 `Can.Write` 作为 Tx 发送
+- [功能]：为 PC MCAL-CAN（C）驱动程序添加 `ecb_cli rpc` JSON-RPC 2.0 服务器
+- [功能]：GUI JSON-RPC 网关 — 外部 `Can.Write` 作为 Tx 传输至实时设备
 - [opt]: 网络中的可选串口
 - 修复设备处理和 CANLE 帧定义一致性，由 @zhangjiance 完成，参见 https://github.com/ecubus/EcuBus-Pro/pull/383
 - 增强原始数据编辑器，增加自动聚焦、工具提示和上下文菜单，由 @zhangjiance 完成，参见 https://github.com/ecubus/EcuBus-Pro/pull/386
diff --git a/docs/zh/um/cli/cli.md b/docs/zh/um/cli/cli.md
index 776e4fa4..0de97513 100644
--- a/docs/zh/um/cli/cli.md
+++ b/docs/zh/um/cli/cli.md
@@ -89,9 +89,9 @@ ecb_cli test <project> <name> [options]
 
 ![alt text](../../../media/um/cli/test.gif)
 
-### JSON-RPC 命令（PC 版 MCAL-CAN）
+### JSON-RPC 命令（PC MCAL-CAN）
 
-启动 JSON-RPC 2.0 服务，让 PC 上的 AUTOSAR MCAL CAN 驱动（C）可以通过 EcuBus-Pro 操作 CAN 硬件。
+启动一个 JSON-RPC 2.0 服务器，以便 PC AUTOSAR MCAL CAN 驱动程序（C）能够与 EcuBus-Pro CAN 硬件通信。
 
 ```bash
 ecb_cli rpc -h
@@ -99,6 +99,6 @@ ecb_cli rpc
 ecb_cli rpc ./project.ecb --auto-init
 ```
 
-报文格式、AUTOSAR `Can_*` 映射、通知以及 C 示例见 [JSON-RPC（PC 版 MCAL-CAN）](./rpc.md)。
+有关线路格式、AUTOSAR `Can_*` 映射、通知和 C 示例，请参阅 [JSON-RPC (PC MCAL-CAN)](./rpc.md)。
 
-图形界面运行时也会提供同一服务（主页 → 设置 → 常规）。该模式下 RPC 写入会作为 Tx 发到已打开的设备，详见协议文档中的 GUI 网关一节。
+同一服务器也在 **GUI** 中运行（主页 → 设置 → 常规）。 RPC 写入通过实时设备的 Tx 传输；请参阅协议文档中的 GUI 网关部分。
diff --git a/docs/zh/um/cli/rpc.md b/docs/zh/um/cli/rpc.md
index b9626f75..4b6dadb7 100644
--- a/docs/zh/um/cli/rpc.md
+++ b/docs/zh/um/cli/rpc.md
@@ -1,181 +1,282 @@
-# CLI JSON-RPC（PC 版 MCAL-CAN）
+# CLI JSON-RPC (PC MCAL-CAN)
 
-`ecb_cli rpc` 会启动一个 **JSON-RPC 2.0** 服务，让 PC 上用 C 实现的 AUTOSAR **MCAL CAN** 驱动可以打开 EcuBus-Pro 的 CAN 适配器、收发报文，并按 `Can_MainFunction_*` 的方式轮询事件。
+`ecb_cli rpc` 启动一个 **JSON-RPC 2.0** 服务器，使得AUTOSAR **MCAL CAN** 驱动（通常用C语言编写）的PC实现可以打开 EcuBus-Pro CAN 适配器，收发帧，并轮询 `Can_MainFunction_*` 风格的事件。
 
-服务端负责真正的硬件。你的 `Can.c` 仍保持 AUTOSAR 形态（`Can_Init`、`Can_Write`、`Can_MainFunction_Read` 等），每个 API 对应一次 JSON-RPC 调用。
+服务器是硬件后端。 您的C代码 `Can.c` 保持AUTOSAR风格（`Can_Init`、`Can_Write`、`Can_MainFunction_Read`，……） 并在每次调用时转发为一条 JSON-RPC 请求。
 
+````
 ```
 [AUTOSAR CanIf / COM]
         |
-[PC Can.c  MCAL]  -- TCP JSON-RPC -->  [ecb_cli rpc]  -- 厂商库 -->  PEAK / Kvaser / Vector / simulate / ...
+[PC Can.c  MCAL]  -- TCP JSON-RPC -->  [ecb_cli rpc]  -- vendor DLL -->  PEAK / Kvaser / Vector / simulate / ...
 ```
+````
 
-POSIX C 示例见 [`resources/examples/mcal_can_rpc`](../../../../resources/examples/mcal_can_rpc/readme.zh.md)。
+一个 POSIX C 示例位于 [`resources/examples/mcal_can_rpc`](../../../../resources/examples/mcal_can_rpc/readme.md)。
 
-## 启动服务
+## 启动服务器
 
-```bash
+````bash
+```
 ecb_cli rpc -h
 ```
+````
 
-```bash
-# TCP（默认）：127.0.0.1:17320
+````bash
+```
+# TCP (默认): 127.0.0.1:17320
 ecb_cli rpc
 
-# 指定地址和端口
+# 绑定其他端口/接口
 ecb_cli rpc -H 127.0.0.1 -p 17320 --log-level=debug
 
-# Can.Init 未提供 controllers[] 时，使用工程里的 CAN 设备
+# 当 Can.Init 没有控制器[]时，使用 EcuBus-Pro 项目中的 CAN 设备
 ecb_cli rpc ./resources/examples/can/Can.ecb
 
-# 启动时立刻打开工程设备（C 侧可省略 Can.Init）
+# 立即打开这些项目设备（C代码可跳过 Can.Init）
 ecb_cli rpc ./project.ecb --auto-init
 
-# Unix domain socket（Linux / macOS）
+# Unix 域套接字（Linux / macOS）
 ecb_cli rpc --socket /tmp/ecb-rpc.sock
 
-# 标准输入/输出，每行一个 JSON（日志打到 stderr）
+# 标准输入输出上每行一个 JSON 对象（日志输出到 stderr）
 ecb_cli rpc --stdio
 ```
+````
 
-## 报文格式
+## 线格式
 
-- 传输：TCP、Unix socket 或 stdio。
-- 分帧：**NDJSON**（一个 JSON + `\n`）。也接受首尾相连的 JSON，以及 LSP 风格的 `Content-Length`。
-- 规范：[JSON-RPC 2.0](https://www.jsonrpc.org/specification)，包含 batch 和通知（无 `id`）。
-- 只使用命名参数（`params` 为对象），方便 C 拼 JSON。
+- 传输方式：TCP、Unix 套接字或 stdio。
+- 帧格式：**NDJSON**（一个 JSON 值 + `\n`）。 也接受拼接的 JSON 和 LSP `Content-Length` 帧。
+- 规格：[JSON-RPC 2.0](https://www.jsonrpc.org/specification) 包括批处理与通知（无 `id`）。
+- 仅提供命名参数（`params` 为对象）。 易于从C语言构建。
 
 请求：
 
-```json
+````json
+```
 {"jsonrpc":"2.0","method":"Can.Write","params":{"hth":0,"id":256,"sdu":[1,2,3,4],"swPduHandle":1},"id":1}
 ```
+````
 
-成功 / 失败：
+成功 / 错误：
 
-```json
+````json
+```
 {"jsonrpc":"2.0","result":{"result":"E_OK","resultCode":0,"ts":1234},"id":1}
 {"jsonrpc":"2.0","error":{"code":-32601,"message":"Method not found: foo"},"id":1}
 ```
+````
 
-CAN 数据可以是字节数组 `[1,2,3]` **或** hex 字符串 `"01 02 03"` / `"0x010203"`。CAN id 可以是 `256`、`"256"` 或 `"0x100"`。
+CAN 有效载荷可接受为字节数组 `[1,2,3]` **或**十六进制字符串 `"01 02 03"` / `"0x010203"`。 CAN ID 接受 `256`、`"256"` 或 `"0x100"`。
 
 ### 错误码
 
-| 代码 | 含义 |
-| --- | --- |
-| -32700 | 解析错误 |
-| -32600 | 非法请求 |
-| -32601 | 方法不存在 |
-| -32602 | 参数非法 |
-| -32603 | 内部错误 |
-| -32000 | CAN / 驱动错误 |
-| -32001 | 控制器或设备不存在 |
-| -32002 | 控制器未 STARTED |
-| -32003 | HTH / HRH 不存在 |
-| -32004 | 超时 |
-| -32005 | 已经初始化 |
+| 代码     | 含义            |
+| ------ | ------------- |
+| -32700 | 解析错误          |
+| -32600 | 无效请求          |
+| -32601 | 方法未找到         |
+| -32602 | 无效参数          |
+| -32603 | 内部错误          |
+| -32000 | CAN / 驱动错误    |
+| -32001 | 控制器或设备未找到     |
+| -32002 | 控制器未启动        |
+| -32003 | HTH / HRH 未找到 |
+| -32004 | 超时            |
+| -32005 | 已初始化          |
 
-AUTOSAR 的 `Can_Write` 对 `E_NOT_OK` / `CAN_BUSY` **不会**走 JSON-RPC error，而是放在 `result` 里。
+AUTOSAR `Can_Write` **不**使用 JSON-RPC 错误来表示 `E_NOT_OK` / `CAN_BUSY`。 这些在 `result` 中返回。
 
-## 两层 API
+## 两个 API 层
 
-| 层次 | 方法 | C MCAL 中的用途 |
-| --- | --- | --- |
-| AUTOSAR 风格 | `Can.Init`、`Can.Write`、`Can.MainFunction_*` 等 | 直接对应 SWS_Can |
-| 底层 | `can.open`、`can.write`、`can.read`、`can.subscribe` 等 | 调试、非 AUTOSAR 客户端 |
+| 层          | 方法                                                   | 在 C MCAL 中使用                      |
+| ---------- | ---------------------------------------------------- | --------------------------------- |
+| AUTOSAR 风格 | `Can.Init`、`Can.Write`、`Can.MainFunction_*`，……       | 直接映射 SWS_Can |
+| 底层         | `can.open`、`can.write`、`can.read`、`can.subscribe`，…… | 启动、调试、非 AUTOSAR 客户端               |
 
-`rpc.discover` 返回完整方法目录（名称、参数、AUTOSAR 对应关系）。
+`rpc.discover` 返回完整的方法目录（名称、参数、AUTOSAR 映射）。
 
-方法名在可能冲突时区分大小写：`can.write`（底层，使用 `controllerId`）与 `Can.Write`（AUTOSAR，使用 `hth`）不是同一个方法。
+方法名区分大小写，以避免冲突：`can.write`（底层，使用 `controllerId`）不是 `Can.Write`（AUTOSAR，使用 `hth`）。
 
 `sys.ping`、`sys.version`、`sys.listMethods`、`sys.shutdown` 始终可用。
 
-`hw.listVendors`、`hw.listDevices`、`hw.getVersion` 用于枚举适配器。
+`hw.listVendors`、`hw.listDevices`、`hw.getVersion` 枚举适配器（`simulate`、`peak`、`kvaser`、`vector`、`zlg`、`slcan`、`candle`，……）。
 
 ## MCAL 映射
 
-| AUTOSAR API | JSON-RPC 方法 |
-| --- | --- |
-| `Can_Init` | `Can.Init` |
-| `Can_DeInit` | `Can.DeInit` |
-| `Can_GetVersionInfo` | `Can.GetVersionInfo` |
-| `Can_SetControllerMode` | `Can.SetControllerMode`（`CAN_T_START` / `CAN_T_STOP` / `CAN_T_SLEEP` / `CAN_T_WAKEUP`） |
-| `Can_GetControllerMode` | `Can.GetControllerMode` |
-| `Can_DisableControllerInterrupts` | `Can.DisableControllerInterrupts`（可嵌套） |
-| `Can_EnableControllerInterrupts` | `Can.EnableControllerInterrupts` |
-| `Can_Write` | `Can.Write` |
-| `Can_GetControllerErrorState` | `Can.GetControllerErrorState` |
-| `Can_GetControllerTxErrorCounter` | `Can.GetControllerTxErrorCounter` |
-| `Can_GetControllerRxErrorCounter` | `Can.GetControllerRxErrorCounter` |
-| `Can_SetBaudrate` | `Can.SetBaudrate`（控制器须为 STOPPED） |
-| `Can_CheckWakeup` | `Can.CheckWakeup` |
-| `Can_MainFunction_Write` | `Can.MainFunction_Write` → `confirmations[]`（`CanIf_TxConfirmation`） |
-| `Can_MainFunction_Read` | `Can.MainFunction_Read` → `indications[]`（`CanIf_RxIndication`） |
-| `Can_MainFunction_BusOff` | `Can.MainFunction_BusOff` |
-| `Can_MainFunction_Wakeup` | `Can.MainFunction_Wakeup` |
-| `Can_MainFunction_Mode` | `Can.MainFunction_Mode` |
+| AUTOSAR API                       | JSON-RPC 方法                                                                            |
+| --------------------------------- | -------------------------------------------------------------------------------------- |
+| `Can_Init`                        | `Can.Init`                                                                             |
+| `Can_DeInit`                      | `Can.DeInit`                                                                           |
+| `Can_GetVersionInfo`              | `Can.GetVersionInfo`                                                                   |
+| `Can_SetControllerMode`           | `Can.SetControllerMode`（`CAN_T_START` / `CAN_T_STOP` / `CAN_T_SLEEP` / `CAN_T_WAKEUP`） |
+| `Can_GetControllerMode`           | `Can.GetControllerMode`                                                                |
+| `Can_DisableControllerInterrupts` | `Can.DisableControllerInterrupts`（可嵌套）                                                 |
+| `Can_EnableControllerInterrupts`  | `Can.EnableControllerInterrupts`                                                       |
+| `Can_Write`                       | `Can.Write`                                                                            |
+| `Can_GetControllerErrorState`     | `Can.GetControllerErrorState`                                                          |
+| `Can_GetControllerTxErrorCounter` | `Can.GetControllerTxErrorCounter`                                                      |
+| `Can_GetControllerRxErrorCounter` | `Can.GetControllerRxErrorCounter`                                                      |
+| `Can_SetBaudrate`                 | `Can.SetBaudrate`（控制器必须处于 `STOPPED` 状态）                                                |
+| `Can_CheckWakeup`                 | `Can.CheckWakeup`                                                                      |
+| `Can_MainFunction_Write`          | `Can.MainFunction_Write` → `confirmations[]`（`CanIf_TxConfirmation`）                   |
+| `Can_MainFunction_Read`           | `Can.MainFunction_Read` → `indications[]`（`CanIf_RxIndication`）                        |
+| `Can_MainFunction_BusOff`         | `Can.MainFunction_BusOff`                                                              |
+| `Can_MainFunction_Wakeup`         | `Can.MainFunction_Wakeup`                                                              |
+| `Can_MainFunction_Mode`           | `Can.MainFunction_Mode`                                                                |
 
 控制器模式：`CAN_CS_UNINIT`、`CAN_CS_STOPPED`、`CAN_CS_STARTED`、`CAN_CS_SLEEP`。
 
-`Can.Init` 打开硬件后控制器处于 **STOPPED**（与 AUTOSAR 一致）。发送前需要 `Can.SetControllerMode` + `CAN_T_START`。
+`Can.Init` 打开硬件但将控制器保持为 **STOPPED**（与 AUTOSAR 相同）。 在 `Can.Write` 之前，使用 `CAN_T_START` 调用 `Can.SetControllerMode`。
+
+如果省略 `hardwareObjects`，默认硬件对象为：
+
+- HTH `controllerId * 2` — 基本发送（动态 CAN ID）
+- HRH `controllerId * 2 + 1` — 基本接收，标准 ID，接受所有
+- HRH `controllerId * 2 + 1000` — 基本接收，扩展 ID，接受所有
+
+### `Can.Init` 配置
+
+````json
+```
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "Can.Init",
+  "params": {
+    "controllers": [
+      {
+        "controllerId": 0,
+        "vendor": "simulate",
+        "handle": 0,
+        "name": "CanCtrl_0",
+        "canfd": false,
+        "bitrate": { "freq": 500000 }
+      }
+    ],
+    "hardwareObjects": [
+      {
+        "hohId": 0,
+        "controllerId": 0,
+        "objectType": "TRANSMIT",
+        "handleType": "BASIC",
+        "idType": "STANDARD"
+      },
+      {
+        "hohId": 1,
+        "controllerId": 0,
+        "objectType": "RECEIVE",
+        "handleType": "BASIC",
+        "idType": "STANDARD",
+        "canId": 0,
+        "idMask": 0
+      }
+    ],
+    "baudRateConfigs": {
+      "0": { "bitrate": { "freq": 500000 } },
+      "1": { "bitrate": { "freq": 250000 } }
+    }
+  }
+}
+```
+````
 
-未提供 `hardwareObjects` 时的默认 Hoh：
+`idMask: 0` 表示“接受该 `idType` 的所有 ID”。 FULL 发送对象需要固定的 `canId`。 BASIC 发送对象在每次 `Can.Write` 中接受 `id`。
 
-- HTH `controllerId * 2` — BASIC 发送（动态 CAN id）
-- HRH `controllerId * 2 + 1` — BASIC 接收，标准帧，接收全部
-- HRH `controllerId * 2 + 1000` — BASIC 接收，扩展帧，接收全部
+如果在 CLI 上传递了项目文件且省略 `controllers`，则将打开项目中的每个 CAN 设备。
 
 ### `Can.Write`
 
-```json
+````json
+```
 {
   "hth": 0,
   "swPduHandle": 1,
   "id": "0x100",
   "sdu": [1, 2, 3, 4, 5, 6, 7, 8],
-  "idType": "STANDARD"
+  "idType": "STANDARD",
+  "canfd": false,
+  "brs": false
 }
 ```
+````
 
 返回 `{ "result": "E_OK"|"E_NOT_OK"|"CAN_BUSY", "resultCode": 0|1|2, "ts": ... }`。
 
-FULL HTH 同时只允许 1 帧在途（否则 `CAN_BUSY`）。BASIC HTH 最多 8 帧。
+FULL HTH 允许一个在途帧（否则返回 `CAN_BUSY`）。 BASIC HTH 最多允许 8 个。
+
+### 轮询 vs 推送通知
 
-### 轮询与推送
+**轮询（典型 MCAL）：** C 调度器中的 `Can_MainFunction_Read` 调用 `Can.MainFunction_Read`，然后针对每个项调用 `CanIf_RxIndication`。
 
-**轮询（MCAL 常用）：** C 调度里 `Can_MainFunction_Read` 调用 `Can.MainFunction_Read`，再对每条调用 `CanIf_RxIndication`。
+**推送：** `can.subscribe` 然后服务器发送通知（无 `id`）：
 
-**推送：** `can.subscribe` 后，服务端发送通知（无 `id`）：`can.rxIndication`、`can.txConfirmation`、`can.controllerBusOff` 等。
+- `can.rxIndication`
+- `can.txConfirmation`
+- `can.controllerBusOff`
+- `can.controllerModeIndication`
+- `can.controllerWakeup`
+- `can.error`
 
-`Can_DisableControllerInterrupts` 会抑制通知（可嵌套），MainFunction 队列仍会填充。
+`Can_DisableControllerInterrupts` 抑制通知（可嵌套）。 MainFunction 队列仍会填充。
 
 ## 底层 CAN 方法
 
-尚未封装 AUTOSAR Hoh 时可以使用：`can.open` / `can.write` / `can.read` / `can.subscribe` / `can.startPeriodSend` 等。`can.open` 打开后会直接进入 STARTED。
+当您尚未包装 AUTOSAR HOH 时很有用：
+
+| 方法                                                                    | 作用                               |
+| --------------------------------------------------------------------- | -------------------------------- |
+| `can.open`                                                            | 打开供应商+句柄，分配 `controllerId`，启动控制器 |
+| `can.close`                                                           | 关闭一个或全部                          |
+| `can.list`                                                            | 控制器 + HOH 映射                     |
+| `can.write` / `can.writeMany`                                         | 按控制器 ID 发送（绕过 HTH）               |
+| `can.read` / `can.readPoll`                                           | 排空此连接的 RX 队列（`timeoutMs` 用于阻塞）   |
+| `can.setMode` / `can.reset`                                           | 模式与总线关闭恢复                        |
+| `can.getState` / `can.getBusLoading`                                  | 模式、错误状态、负载                       |
+| `can.startPeriodSend` / `can.stopPeriodSend` / `can.changePeriodData` | 周期发送（软件定时器，或硬件定时器（如果供应商支持））      |
+
+## C 驱动示例
+
+````c
+```
+Std_ReturnType Can_Write(Can_HwHandleType hth, const Can_PduType *pdu) {
+    /* 构建 JSON-RPC Can.Write，包含 hth、pdu->id、pdu->sdu、pdu->swPduHandle */
+    /* resultCode 0 -> E_OK, 2 -> CAN_BUSY, 否则 E_NOT_OK */
+}
+
+void Can_MainFunction_Read(void) {
+    /* 调用 Can.MainFunction_Read，对于每个指示：CanIf_RxIndication(hrh, id, len, sdu) */
+}
+```
+````
+
+保持持久的 TCP 连接。 不要每次 `Can_Write` 都重新连接。
 
-## Simulate 回环（无硬件）
+## 模拟环回（无硬件）
 
-打开两个 `simulate` handle，在其中一个上发送的帧会出现在另一个的 RX 中（约 1 ms）：
+打开两个 `simulate` 句柄。 一个句柄上写入的帧会在另一个句柄上显示为 RX（约 1 毫秒后）：
 
-```json
+````json
+```
 {"jsonrpc":"2.0","method":"can.open","params":{"vendor":"simulate","handle":0,"controllerId":0},"id":1}
 {"jsonrpc":"2.0","method":"can.open","params":{"vendor":"simulate","handle":1,"controllerId":1},"id":2}
 {"jsonrpc":"2.0","method":"can.write","params":{"controllerId":0,"id":"0x123","data":[1,2,3,4]},"id":3}
 {"jsonrpc":"2.0","method":"can.read","params":{"controllerId":1,"timeoutMs":200},"id":4}
 ```
+````
 
 ## GUI 网关（EcuBus 客户端已在运行）
 
-当 **EcuBus-Pro 图形界面** 已启动时，同一套 JSON-RPC 由应用程序提供（默认 `127.0.0.1:17320`）。此时不要再运行 `ecb_cli rpc`，CAN 适配器已经由 GUI 占用。
+当 **EcuBus-Pro GUI** 运行时，相同的 JSON-RPC API 由应用程序提供（默认 `127.0.0.1:17320`）。 在这种情况下，您**无需**启动 `ecb_cli rpc` — GUI 已拥有 CAN 适配器。
 
-开关、地址和端口在 **主页 → 设置 → 常规**。修改绑定后点 **应用 RPC**。`sys.version` 会返回 `"role": "gateway"`。
+启用/禁用、主机和端口位于 **Home → Setting → General** 下。 更改绑定设置后，点击 **Apply RPC**。 `sys.version` 返回 `"role": "gateway"`。
 
 方向：
 
-| 来源 | EcuBus 显示 | RPC 客户端看到 |
-| --- | --- | --- |
-| 外部 `Can.Write` / `can.write` | **Tx**（`dir: OUT`） | TX 确认（不会把本帧当 RX 回显） |
-| 硬件接收 | Rx | RX 指示 |
+| 来源                           | EcuBus 显示的内容                           | RPC 客户端看到的内容     |
+| ---------------------------- | -------------------------------------- | ---------------- |
+| 外部 `Can.Write` / `can.write` | **Tx** (`dir: OUT`) | TX 确认（无自回显作为 RX） |
+| 硬件 RX                        | Rx                                     | RX 指示            |
 
-RPC 写入走与 GUI 相同的 `writeBase`，会作为 Tx 发到总线。请先在 GUI 里启动工程以打开设备，然后 `Can.Init` 会返回已附着的控制器。不要与 `ecb_cli rpc` 占用同一 TCP 端口。
+RPC 写入使用与 GUI 相同的 `writeBase` 路径，因此它们作为 Tx 发送到总线上。 先在 GUI 中启动项目以便设备打开；然后 `Can.Init` 返回附加的控制器。 不要同时在相同的 TCP 端口上运行 `ecb_cli rpc`。
diff --git a/docs/zh/um/setting/general.md b/docs/zh/um/setting/general.md
index dcd401c8..6ad47b4f 100644
--- a/docs/zh/um/setting/general.md
+++ b/docs/zh/um/setting/general.md
@@ -16,6 +16,6 @@
 
 ## JSON-RPC
 
-EcuBus 图形界面运行时，其他程序可以通过 JSON-RPC（默认 `127.0.0.1:17320`）访问已打开的 CAN 设备。外部程序写入的帧在跟踪窗口中显示为 **Tx**。
+当 EcuBus 图形界面运行时，其他程序可通过 JSON-RPC（默认 `127.0.0.1:17320`）访问实时 CAN 设备。 这些程序写入的帧在跟踪中显示为 **Tx**。
 
-修改主机或端口后点击 **应用 RPC**。协议说明见 [CLI JSON-RPC](../cli/rpc.md)。
+更改主机或端口后，点击 **应用 RPC**。 有关协议，请参阅 [CLI JSON-RPC](../cli/rpc.md)。
diff --git a/resources/examples/mcal_can_rpc/readme.zh.md b/resources/examples/mcal_can_rpc/readme.zh.md
index eff1b027..fea191a5 100644
--- a/resources/examples/mcal_can_rpc/readme.zh.md
+++ b/resources/examples/mcal_can_rpc/readme.zh.md
@@ -1,10 +1,10 @@
-# 通过 JSON-RPC 实现 PC 版 MCAL-CAN
+# PC MCAL-CAN 通过 JSON-RPC
 
-本示例展示如何用 **C** 在 PC 上实现 AUTOSAR MCAL CAN，并通过 `ecb_cli rpc` 操作 EcuBus-Pro 的 CAN 硬件。
+此示例展示了 AUTOSAR MCAL CAN 的 **C** 语言 PC 实现如何通过 `ecb_cli rpc` 与 EcuBus-Pro 硬件通信。
 
-如果 **EcuBus-Pro 图形界面** 已经在运行，不要再启动 `ecb_cli rpc`，直接连同一 TCP 端口（默认 `127.0.0.1:17320`）。该模式下 `Can_Write` 会在 EcuBus 跟踪里显示为 **Tx**。请先在 GUI 中启动工程。
+如果 **EcuBus-Pro GUI** 已在运行，请跳过 `ecb_cli rpc`，直接连接到同一 TCP 端口（默认为 `127.0.0.1:17320`）。 在该模式下，您的 `Can_Write` 帧将作为 EcuBus 跟踪中的 **Tx** 显示。 请先在 GUI 中启动项目。
 
-量产 `Can.c` 应保留 AUTOSAR 函数签名（`Can_Init`、`Can_Write`、`Can_MainFunction_Read` 等），每个函数对应一次 JSON-RPC 调用。`can_rpc_demo.c` 是一个小型 POSIX 客户端，在两个 `simulate` 控制器上走完这一流程。
+您的生产 `Can.c` 应保留 AUTOSAR 签名（`Can_Init`、`Can_Write`、`Can_MainFunction_Read` 等） 并将每个函数实现为一次 JSON-RPC 调用。 `can_rpc_demo.c` 是一个小型 POSIX 客户端，它在两个 `simulate` 控制器上执行该序列。
 
 ## 运行
 
@@ -23,14 +23,14 @@ make
 # 或：./can_rpc_demo 127.0.0.1 17320
 ```
 
-你应看到 `Can.Init`、`Can.SetControllerMode`、`Can.Write`，然后 `Can.MainFunction_Read` 在控制器 1 上返回回环帧。
+您将看到 `Can.Init`、`Can.SetControllerMode`、`Can.Write`，随后是 `Can.MainFunction_Read` 在控制器 1 上返回回环帧。
 
 ## 文件
 
-| 文件 | 作用 |
-| --- | --- |
-| `can_rpc.h` | 方法名宏以及 `E_OK` / `CAN_BUSY` 常量 |
-| `can_rpc_demo.c` | POSIX TCP NDJSON 客户端 |
-| `Makefile` | `cc -std=c11` |
+| 文件               | 作用                            |
+| ---------------- | ----------------------------- |
+| `can_rpc.h`      | 方法名宏以及 `E_OK` / `CAN_BUSY` 常量 |
+| `can_rpc_demo.c` | POSIX TCP NDJSON 客户端          |
+| `Makefile`       | `cc -std=c11`                 |
 
-完整协议见 [CLI JSON-RPC](/docs/zh/um/cli/rpc.md)。
+完整协议：[CLI JSON-RPC](/docs/en/um/cli/rpc.md)。