feat(ota): Cat1远程升级联调进度(App侧收发链路打通, 待整包实测)

- Update.c/h: NetUpgrade模块(0x7D流式组帧/0x81会话/断点续传/CRC32/TX队列) - spiflash.c/h: 固件暂存区(扇区4038~4095)+进度区(4037), 日志回绕点前移 - CatOneTask.c: +LIPURC异步分发(循环解析同批多URC); 释放CatOneRev_Sem保REV_DATA快速返回; 升级应答帧发完即回WAIT_SEND - CatOneTask.c: USART1专用Cat1(上电恒连), 调试日志走RS485 Ch1, CAT1日志常开 - Public.c/h: AsciiToHex长度参数uint8->uint16(修432字符帧截断) - bsp.c/h, main.c, board.c, DebugCmd.c: APP_UPDATE_SPI_FLAG及配套适配 - 联调修复: sscanf锚点/窗口差值判断/AsciiToHex截断/URC被AT状态机吞帧/信号量缺失
2026-09-24 17:14:02 +08:00
parent 314ff67f26
commit f206b8f7dd
15 changed files with 630 additions and 111 deletions
@@ -0,0 +1,85 @@
+# Cat1 远程升级方案设计（待评审）
+
+## 总体架构
+
+App 扮演"接收端"角色（与 Boot 在 RS485 升级中的角色相同），服务器扮演升级主机：
+
+```
+服务器(升级主机) --TCP--> 合宙Cat1模组 --USART1--> App(RT-Thread)
+    │                                          ├─ 收0x7D帧(0x81/0x82) → 固件分包写外部SPI Flash暂存区
+    │←────────── 0x01 ACK(带进度) ──────────────┤
+    │                                          └─ 收完→CRC32校验→置UpdateFlag=APP_UPDATE_SPI_FLAG→复位
+复位
+    └→ Boot: 检测APP_UPDATE_SPI_FLAG
+         → SPI Flash逐扇区读 → 写内部B区 → CRC32(B)
+         → 搬运B→A → CRC32(A) → 擦SPI Flash暂存区 → 置完成标志 → 复位跳App
+```
+
+**升级协议完全复用 RS485 的 0x7D 帧**：帧头 0x7D + DevMac(6) + Cmd(1) + PayloadLen(1) + Payload + CRC16(Modbus)，命令 0x81 升级请求{PackageNum, AppSize, AppCrc32} / 0x82 数据{PackageIndex, PackageNum, DataLen, Data[200]} / 0x01 ACK / 0x02 请求数据。服务器端协议不变。
+
+## 关键决策与理由
+
+1. **Boot 不驱动 Cat1**：AT 注网 30 秒起、Boot 仅 32KB 分区（当前 Code 16KB）、模组 TCP 连接态在 MCU 复位后不可控。收包/重试/续传等复杂逻辑全部放 App（RTOS 资源丰富），Boot 只做"从外部 Flash 搬运到 B 区"这一简单确定性动作。
+2. **固件暂存外部 SPI Flash**：16MB 尾部划 58×4KB=232KB 暂存区（扇区 4038~4095），日志环形写入回绕点同步从 16MB 末尾前移到扇区 4038。
+3. **复用 UpdateFlag 机制**：新增标志值 `APP_UPDATE_SPI_FLAG`（建议 0xA5A55A5A，与现有 START=0x55AA5A5A / UPDATE=0xA5A5AA55 / BOOT_UPGRADE=0x5A5A55A5 不冲突），`boot_para_t` 结构不变，RS485 本地升级路径完全不受影响。
+4. **依赖 TCP 可靠有序**：应用层丢包仅发生在断连/模组重启，因此用"断点续传 + 超时重发请求"而非滑动窗选择重传，状态机与 Boot 版本同构，服务器实现简单。
+
+## 升级流程（含 Cat1 特化处理）
+
+1. 服务器 → `0x81{PackageNum, AppSize, AppCrc32}`
+2. App 校验 DevMac/合法性（AppSize==0 或 >232KB 拒绝）→ 回 `0x01 ACK`：
+   - 载荷建议扩展为 `{Status, ResumedIdx}`：`0x20`=全新开始（App 擦暂存区）、`0x21`=断点续传（已收 ResumedIdx 包，服务器从该包续发）。**注意：原 0x01 载荷 1 字节(0x20)，扩展为 3 字节需服务器端同步适配（新版本服务器）**
+3. 服务器从 ResumedIdx 起发 `0x82{PackageIndex, ...}`：
+   - **流控（推荐窗口式）**：服务器连发 W 包（建议 W=8~16）→ App 校验 PackageIdx 顺序写入暂存区（乱序/重复包丢弃）→ App 主动发 `0x02{期望包号}` → 服务器继续。停等式（每包一问一答）在 Cat1 上太慢：1160 包 × RTT≈2~5 分钟+，窗口式约 30~60 秒
+   - TCP 保证有序，App 端只需顺序校验 + 期望包号判定
+4. App 收完 → `CRC32(暂存区, AppSize)`：
+   - 通过 → 回 `0x01{0x30 完成}` → 写 boot_para_t{AppSize, Crc32Check, UpdateFlag=APP_UPDATE_SPI_FLAG} → 200ms → 复位
+   - 失败 → 回 `0x01{0x31 CRC错}` → 不复位，清暂存区等待服务器重发（可多次）
+5. Boot 检测 `APP_UPDATE_SPI_FLAG` → 逐 8KB：读外部 2×4KB 扇区 → 擦写内部 B 区 1×8KB 扇区 → `CRC32(B)` → `CopyAppBtoA()`（现有）→ `CRC32(A)` → **擦外部暂存区（防残留误判，同 RS485 路径 B 区擦除教训）** → 置 `APP_BOOT_UPGRADE_FLAG` → 复位跳 App
+6. App 启动（`APP_BOOT_UPGRADE_FLAG`）→ 擦外部参数分区 → 上线后服务器可查版本确认升级成功
+
+### 超时与重试参数（Cat1 特化，均为 App 侧状态机）
+
+| 参数 | Boot RS485 值 | Cat1 版建议 | 理由 |
+|------|--------------|------------|------|
+| 等包超时 | 500ms | **3 秒** | Cat1 RTT + 模组缓冲 |
+| 重试次数 | 3 | **5** | 偶发断连需模组重连 |
+| 断连恢复 | — | 模组重连（现有逻辑）后服务器重发 0x81，ACK 带进度续传 | TCP 断开后应用层无从补偿 |
+| 整体超时 | — | 30 分钟无进展 → 放弃升级（清标志，不复位） | 防止无限等待 |
+
+### 断电自愈矩阵（Cat1 路径）
+
+| 断电/异常时机 | 恢复行为 |
+|--------------|---------|
+| App 收包中断连/断电 | 暂存区+进度保留 → 重连后 0x81 续传 |
+| App 置标志后、复位前 | Boot 正常走 SPI Flash→B→A |
+| Boot 搬运中（写B区）断电 | UpdateFlag 仍为 SPI_FLAG → B 区 CRC 有效则重搬；无效则清标志回老 App |
+| 搬运完、擦暂存区中断电 | 参数未写 → B CRC 判定重搬（B 仍在）；参数已写 → 跳新 App |
+
+## 改动清单
+
+### App（GateWay 工程）
+| 文件 | 改动 |
+|------|------|
+| `spiflash.h/c` | 新增 `FLASH_FW_STASH_BASE`（扇区 4038 起）+ StashErase/StashWrite/StashRead；`AddLog` 回绕点 16MB→扇区 4038；新增 CRC32（与 Boot GetCrc32 同算法 0xEDB88320） |
+| `CatOneTask.c`（或新文件） | Cat1 通道增加 0x7D 帧组帧解析（`+LIPURC` hex→二进制后按 0x7D 组帧，与现有 0x7A 链路并存，按帧头区分）；升级接收状态机（移植 Boot AnalyzeData+BL 状态机，超时/重试参数按上表） |
+| `Update.c` | 新增 `UpdateFromStash()`：写 boot_para_t（APP_UPDATE_SPI_FLAG + AppSize + Crc32Check）→ 复位 |
+| `bsp.h`（App） | `APP_UPDATE_SPI_FLAG` 宏；`boot_para_t` 不动 |
+| `main.h`（App） | 版本号随迭代递增 |
+
+### Boot（HC32F460BootLoader 工程）
+| 文件 | 改动 |
+|------|------|
+| `bsp.c/h` | SPI Flash 驱动：与 App 相同总线（需确认外部 Flash 挂载的 SPI 外设与引脚，Boot 复用），W25Q 写使能/扇区擦/页读命令；约 +2~3KB（Boot 当前 16KB，32KB 分区内余量足够） |
+| `main.c/h` | `APP_UPDATE_SPI_FLAG` 宏 + main() 决策分支（SPI_FLAG → 新状态 `BL_STASH_TO_B`）；`BL_STASH_TO_B`：逐 8KB 外部读→B 区写→CRC(B) 通过进 `BL_COPY_TO_A`（现有），失败清标志回老 App；`BL_COPY_TO_A` 成功分支追加"擦外部暂存区" |
+
+### 服务器端（不在本仓库，需同步开发）
+- 实现 0x81/0x82 升级主机逻辑：窗口流控（W 包一批）、解析 0x02 期望包号、断点续传（ACK 的 ResumedIdx）、完成/失败状态处理
+
+## 风险与待确认项
+
+1. **调试口与 Cat1 共用 USART1（PB08 方向切换）**：升级期间必须保证 UART 方向锁定在 Cat1 侧（`CAT1_ON()`），升级状态机运行期间禁止调试打印切向（`U_DBG_LOG` 若触发 `DBG_ON()` 会破坏 TCP 数据）。实施时需审查 DEBUG=1 下所有升级路径的打印。
+2. **外部 Flash 挂载总线待确认**：读 spiflash.c 确认 SPI 外设号/引脚/QSPI 模式，Boot 驱动按此实现。
+3. **日志区历史数据**：回绕点前移到扇区 4038（约 15.77MB），已存历史日志超出的部分会被覆盖——现网日志增长慢，实际影响小，但需知晓。
+4. **0x01 ACK 载荷扩展**（1→3 字节）需服务器端配合，若服务器不改动则退化为停等式流控（慢但兼容）。
+5. **升级流量**：232KB/次，Cat1 资费可忽略。
@@ -432,18 +432,18 @@
        <Bp>
          <Number>0</Number>
          <Type>0</Type>
-          <LineNumber>569</LineNumber>
+          <LineNumber>503</LineNumber>
          <EnabledFlag>1</EnabledFlag>
-          <Address>0</Address>
+          <Address>54178</Address>
          <ByteObject>0</ByteObject>
          <HtxType>0</HtxType>
          <ManyObjects>0</ManyObjects>
          <SizeOfObject>0</SizeOfObject>
          <BreakByAccess>0</BreakByAccess>
-          <BreakIfRCount>0</BreakIfRCount>
+          <BreakIfRCount>1</BreakIfRCount>
          <Filename>..\source\User\Src\CatOneTask.c</Filename>
          <ExecCommand></ExecCommand>
-          <Expression></Expression>
+          <Expression>\\GateWay\../source/User/Src/CatOneTask.c\503</Expression>
        </Bp>
      </Breakpoint>
      <WatchWindow1>
@@ -76,9 +76,9 @@ void rt_hw_board_init(void)

 static int uart_init(void)
 {
-//#error "TODO 2: Enable the hardware uart and config baudrate."
-	DbgOrCat1Uart_Config(500000);
-//  RS485Ch1_Config(500000);
+	/*USART1专用Cat1: 上电恒115200+CAT1方向*/
+	DbgOrCat1Uart_Config(115200);
+	CAT1_ON();
  return 0;
 }
 INIT_BOARD_EXPORT(uart_init);
@@ -86,15 +86,8 @@ INIT_BOARD_EXPORT(uart_init);
 void rt_hw_console_output(const char *str)
 {
 	rt_enter_critical();
-	switch(GateWay.ConfigPara.Duch) {
-		case CH_RS485_1: RS485Ch1UartSend((uint8_t *)str, strlen(str)); break;
-		case CH_RS485_2: RS485Ch2UartSend((uint8_t *)str, strlen(str)); break;
-		case CH_ETH:     EthUartSend((uint8_t *)str, strlen(str)); break;
-		case CH_LORA:    Sx1276LoRaSendBuffer((uint8_t *)str, strlen(str)); break;
-		case CH_CAT1:    DebugOrCat1UartSend((uint8_t *)str, strlen(str)); break;
-		case CH_DBG:     DebugOrCat1UartSend((uint8_t *)str, strlen(str)); break;
-		default:         DebugOrCat1UartSend((uint8_t *)str, strlen(str)); break;
-	}
+	/*USART1专用Cat1后, 调试输出统一走RS485 Ch1*/
+	RS485Ch1UartSend((uint8_t *)str, strlen(str));
 	rt_exit_critical();
 }

@@ -43,24 +43,8 @@ void Debug_Printf(char *format, ...)
 	va_list args;
 	va_start(args, format);
 	vsprintf(&tempBuff[0], format, args);
-	if(GateWay && GateWay->ConfigPara.Duch == CH_CAT1
-		&& GateWay->ConfigPara.Much != CH_CAT1
-		&& GateWay->ConfigPara.Auch != CH_CAT1
-		&& !(GateWay->ConfigPara.CuchMask & CUCH_CAT1)) {
-		char *line = tempBuff;
-		while(line && *line) {
-			char *end = strstr(line, "\r\n");
-			uint16_t n = end ? (uint16_t)(end - line + 2) : (uint16_t)strlen(line);
-			if(n > 240) n = 240;
-			if(n > 0) Cat1DuchSend(line, n);
-			line = end ? end + 2 : NULL;
-		}
-	} else {
+	/*USART1专用Cat1后, 调试输出统一走RS485 Ch1(经rt_kprintf→rt_hw_console_output)*/
 	rt_kprintf(tempBuff);
-	}
-	if(ParaEchoCh1) {
-		RS485Ch1UartSend((uint8_t *)tempBuff, strlen(tempBuff));
-	}
 	va_end(args);
 }
 /*****************************************************************************************
@@ -98,18 +82,8 @@ void Debug_Thread_Entry(void *parameter)
 *****************************************************************************************/
 void DbgOrCat1RxIrqCallback(uint8_t rData)
 {
-	if(ChannelIsActive(GateWay->ConfigPara, CH_CAT1)) {
+	/*USART1专用Cat1: 接收数据无条件进Cat1处理(不再按配置分流)*/
 	Cat1IrqCallback(rData);
-		return;
-	}
-
-	if(DebugRxTimeOut1mSCnt == 0)
-		DebugRxLen = 0;
-
-	DebugRxTimeOut1mSCnt = 3;
-	if(DebugRxLen < DBG_RX_LEN_MAX) {
-		DebugRxBuff[DebugRxLen++] = rData;
-	}
 }


@@ -1305,9 +1279,8 @@ void DebugCmdSelDebugChannel(int argc, char *argv[])
 		DBG_LOG("Invalid channel.\r\n");
 		return;
 	}
-	if((ch == CH_DBG && ChannelIsActive(GateWay->ConfigPara, CH_CAT1))
-		|| (ch == CH_CAT1 && ChannelIsActive(GateWay->ConfigPara, CH_DBG))) {
-		DBG_LOG("USART1 occupied by dbg/cat1 pair.\r\n");
+	if(ch == CH_DBG || ch == CH_CAT1) {
+		DBG_LOG("USART1 is dedicated to Cat1, duch switch denied.\r\n");
 		return;
 	}
 	if(ChannelIsActive(GateWay->ConfigPara, ch)
@@ -1,4 +1,4 @@
-#ifndef __PUBLIC_H
+#ifndef __PUBLIC_H
 #define	__PUBLIC_H

 #include "bsp.h"
@@ -359,7 +359,7 @@ struct GateWay_t{
 int MuchRevCallBack(GateWayPara GateWay, uint8_t *rData, uint16_t rLen);
 int AuchRevCallBack(GateWayPara GateWay, uint8_t *rData, uint16_t rLen);
 uint16_t CRC_Modbus(uint16_t wBase, __IO uint8_t *para, uint16_t length);
-uint8_t AsciiToHex(char *ASCData, uint8_t *HexData, uint8_t sLen);
+uint16_t AsciiToHex(char *ASCData, uint8_t *HexData, uint16_t sLen);
 void HexToAscii(uint8_t *HexData, char *ASCData, uint8_t sLen);
 int NetCommOrgData(GateWayPara GateWay, uint8_t *MegData, uint8_t *OutData);
 int CommUnitAnalyze(GateWayPara GateWay, uint8_t *rData, uint16_t rLen, SendData Response);
@@ -32,5 +32,12 @@ typedef struct {
 //输出接口
 void Update(uint8_t *PayLoad);
 void UpdateInit(void);
+
+/*Cat1远程升级(0x7D帧)接口 - CatOneTask调用: 固件分包写外部SPI Flash暂存区, 收完置APP_UPDATE_SPI_FLAG复位*/
+bool NetUpgradeFeed(uint8_t *data, uint16_t len);		//喂入Cat1下行数据片段, 返回true=已被升级模块消费
+bool NetUpgradePopTx(uint8_t *Out, uint16_t *OutLen);	//取待发应答帧(0x01/0x02, 0x7D原始帧)
+bool NetUpgradeActive(void);							//升级会话进行中
+void NetUpgradeTick(void);								//1ms轮询: 超时催发与会话放弃
+void UpdateFromStash(uint32_t AppSize, uint32_t Crc32);	//暂存区校验通过后置标志复位进Boot
 #endif

@@ -35,6 +35,7 @@
 #define	APP_START_FLAG						0x55AA5A5A
 #define	APP_UPDATE_FLAG						0xA5A5AA55
 #define	APP_BOOT_UPGRADE_FLAG				0x5A5A55A5
+#define	APP_UPDATE_SPI_FLAG					0xA5A55A5A	//Cat1远程升级: 固件已存外部SPI Flash暂存区, Boot据此搬运


 #define	WATCH_DOG					1
@@ -40,6 +40,12 @@ uint32_t SpiFlashReadId(void);
 #define	LOG_INFO_START_SECTOR										0x02
 #define	LOG_SAV_START_SECTOR										0x03

+/*固件升级暂存区(外部Flash尾部): 扇区4037=升级进度区, 扇区4038~4095=固件镜像(232KB,与Boot A/B分区一致)*/
+#define	FLASH_FW_STASH_PROG_SECTOR							4037
+#define	FLASH_FW_STASH_SECTOR										4038
+#define	FLASH_FW_STASH_SECTORS									58
+#define	LOG_SAV_END_ADDR												(FLASH_FW_STASH_PROG_SECTOR * SPIFLASH_SECTORSIZE)
+
 //#if (LORA_MODULE == WH_LR36_L)
 //#define	LOG_SAV_SIZE														78
 //#define	LOG_SAV_NUM_SECTOR											52			//每扇区存储数量
@@ -70,6 +76,12 @@ void AddLog(uint8_t *wData, uint32_t wLen);
 int ReadLog(LogHeader Header, uint8_t **wData, uint32_t LogIdx);
 int ReadPara(uint8_t *Para, uint32_t ParaLen);
 int WritePara(uint8_t *Para, uint32_t ParaLen);
+void FwStashEraseAll(void);
+void FwStashProgRead(uint8_t *rData, uint16_t rLen);
+void FwStashProgWrite(uint8_t *wData, uint16_t wLen);
+void FwStashEraseSector(uint32_t SectorIdx);
+int FwStashWrite(uint8_t *wData, uint32_t Offset, uint16_t wLen);
+int FwStashRead(uint8_t *rData, uint32_t Offset, uint16_t rLen);

 /* USER CODE END */
 	
@@ -1,15 +1,18 @@
 #include "CatOneTask.h"
 #include "Public.h"
 #include "DebugCmd.h"
+#include "Update.h"

 static rt_sem_t CatOneRev_Sem = RT_NULL;
 static rt_sem_t CatOneIRQ_Sem = RT_NULL;
 static rt_thread_t Cat1Rev_Thread = RT_NULL;

-static uint8_t CAT1DispEn = false;
+static uint8_t CAT1DispEn = true;	/*默认常开: Cat1调试信息始终输出, 可用Cat1DBGOnOff()动态关闭*/
 static CatOne_t CatOne;

-static char CatOneRxBuff[CAT_ONE_REV_LEN_MAX];
+#define	CAT_ONE_URC_LEN_MAX					4096			//+LIPURC一批连发8包约3.6K, 预留4K
+
+static char CatOneRxBuff[CAT_ONE_URC_LEN_MAX];
 static uint16_t CatOneRxLen;

 static uint8_t CatOneTxBuff[CAT_ONE_REV_LEN_MAX];
@@ -298,41 +301,11 @@ void CatOneAtCmdAnalyze(char *RxBuff)
 			CatOne.ATCmdRet = CAT_ONE_RET_ERR;
 			break;
 		case CAT_ONE_AT_NULL:
-			p = strstr(RxBuff, "+LIPURC");
-			if(p != NULL) {
-				char rData[120];
-				uint8_t  hData[60];
-				int rLen, hLen, ret;
-
-				if(strstr(p, "+LIPURC: 0,0") != NULL) {
-					CAT1_DBG_LOG("TCP connection disconnected.\r\n\r\n");
-					CatOne.TcpConnFlag = false;
-					CatOne.Cat1Status = CAT_ONE_OFF;
-					return;
-				}
-
-				ret = sscanf(p, "+LIPURC: 0,1,%d,%119s\r\n", &rLen, rData);
-				if(ret == 2) {
-					if(rLen < 24)
-						return;
-					memset(hData, 0x00, 60);
-					hLen = AsciiToHex(rData, hData, rLen);
-					CatSendErrCnt = 0;
-					if(CatOne.GateWay->ConfigPara.Much == CH_CAT1)
-						CatOne.GateWay->MuchRevCallBack(CatOne.GateWay, hData, hLen);
-					else
-						CatOne.GateWay->AuchRevCallBack(CatOne.GateWay, hData, hLen);
-				}
-				else {
-					return;
-				}
-				rt_sem_release(CatOneRev_Sem);
-				return;
-			}
 			if(CatOne.TcpConnFlag && RxBuff[0] > ' ') {
 				DebugAnalyze(CatOne.GateWay, (uint8_t *)RxBuff, strlen(RxBuff));
 				return;
 			}
+		break;
 		default:
 			CatOne.ATCmdRet = CAT_ONE_RET_ERR;

@@ -415,6 +388,9 @@ void CatOneLoopHandler(void)
 	static rt_err_t result;
 	uint16_t ret;
 	static uint8_t Cat1RevErrCnt = 0;
+	static uint8_t Cat1UpgTxFlag = 0;	/*当前LIPSEND是否升级应答帧: 发完即回WAIT_SEND*/
+
+	NetUpgradeTick();		/*Cat1远程升级会话超时管理*/

 	switch(CatOne.Cat1Status){
 		case CAT_ONE_IDEL:
@@ -493,6 +469,13 @@ void CatOneLoopHandler(void)
 			break;

 		case CAT_ONE_WAIT_SEND:
+			/*Cat1远程升级应答帧优先(0x7D原始帧直发, 绕过0x7A打包)*/
+			if(NetUpgradePopTx(CatOneTxBuff, &CatOneTxLen)) {
+				CatSendErrCnt = 0;
+				Cat1UpgTxFlag = 1;	/*升级应答帧标记*/
+				CatOne.Cat1Status = CAT_ONE_SEND_DATA;
+				break;
+			}
 			result = rt_mq_recv(ChannelMQ(*CatOne.GateWay, CH_CAT1), Payload, CAT_ONE_REV_LEN_MAX, 1000);
 			if(result == RT_EOK) {
 				CatSendErrCnt = 0;
@@ -527,7 +510,13 @@ void CatOneLoopHandler(void)
 				Cat1RevErrCnt = 0;
 				break;
 			}
+			if(Cat1UpgTxFlag) {	/*升级应答帧: 发完即回WAIT_SEND取下一帧, 不等服务器响应*/
+				Cat1UpgTxFlag = 0;
+				CatOneAtCmdSend(CAT_ONE_LIPSEND, 5000, CAT_ONE_WAIT_SEND);
+			}
+			else {
 				CatOneAtCmdSend(CAT_ONE_LIPSEND, 5000, CAT_ONE_REV_DATA);
+			}
 			break;

 		case CAT_ONE_REV_DATA:
@@ -602,7 +591,6 @@ void CatOneLoopHandler(void)
 			CAT1_DBG_LOG("Cat1 Power Off!\r\n");
 			CatOne.Cat1Status = CAT_ONE_IDEL;
 	CatOne.ResetDelayCnt = CATONE_RESET_DELAY_TIME_MAX;
-			DBG_ON();
 	break;

 		case CAT_ONE_RESET:
@@ -644,10 +632,54 @@ static void CatOneInit(GateWayPara GateWay)
 		GateWay->MuchRevCallBack : GateWay->AuchRevCallBack;
 }

+/*+LIPURC异步事件统一分发: 与AT状态机无关, 任何状态下都能处理升级帧/业务数据*/
+/*一批数据包的URC会连发, 多条可能挤进同一缓冲块: 必须循环解析每一条*/
+static void CatOneUrcHandle(GateWayPara GateWay, char *RxBuff)
+{
+	static char rData[3010];		/*static: 大缓冲+单线程访问*/
+	static uint8_t hData[1510];
+	char *p;
+	int rLen = 0, hLen;
+
+	if(strstr(RxBuff, "+LIPURC: 0,0") != NULL) {
+		CAT1_DBG_LOG("TCP connection disconnected.\r\n\r\n");
+		CatOne.TcpConnFlag = false;
+		CatOne.Cat1Status = CAT_ONE_OFF;
+		return;
+	}
+
+	p = strstr(RxBuff, "+LIPURC: 0,1,");
+	while(p != NULL) {
+		if(sscanf(p, "+LIPURC: 0,1,%d,%3000s", &rLen, rData) == 2) {
+			if(rLen >= 24) {
+				if((int)strlen(rData) >= rLen) {
+					memset(hData, 0x00, sizeof(hData));	/*ASCII hex转二进制(服务器下发为hex文本)*/
+					hLen = AsciiToHex(rData, hData, rLen);
+					CatSendErrCnt = 0;
+					if(hLen > 0 && NetUpgradeFeed(hData, hLen)) {
+						/*0x7D升级帧已由Cat1远程升级模块消费*/
+					}
+					else if(GateWay->ConfigPara.Much == CH_CAT1)
+						GateWay->MuchRevCallBack(GateWay, hData, hLen);
+					else
+						GateWay->AuchRevCallBack(GateWay, hData, hLen);
+				}
+				else {
+					CAT1_DBG_LOG("LIPURC trunc, drop!\r\n");
+				}
+			}
+		}
+		else {
+			CAT1_DBG_LOG("LIPURC parse fail, drop!\r\n");
+		}
+		p = strstr(p + 13, "+LIPURC: 0,1,");	/*头部长13字节, 继续找下一条URC*/
+	}
+	rt_sem_release(CatOneRev_Sem);	/*通知AT状态机: 已收到服务器数据(维持REV_DATA快速返回)*/
+}
 void CatOneRev_Thread_Entry(void *parameter)
 {
 	rt_err_t result;
-	char RxBuffTemp[CAT_ONE_REV_LEN_MAX];
+	static char RxBuffTemp[CAT_ONE_URC_LEN_MAX];	/*static: 大缓冲避撑爆线程栈(单线程访问)*/

 	GateWayPara GateWay = (GateWayPara)parameter;

@@ -659,15 +691,14 @@ void CatOneRev_Thread_Entry(void *parameter)
 			memcpy(RxBuffTemp, CatOneRxBuff, CatOneRxLen);
 			RxBuffTemp[CatOneRxLen] = 0;
 			CatOneRxLen = 0;
-			char *urc = strstr(RxBuffTemp, "+LIPURC: 0,1,");
-			if(urc) {
-				char *data = strchr(strchr(strchr(urc, ',')+1, ',')+1, ',') + 1;
-				char *end = strchr(data, '\r');
-				if(end) *end = 0;
-				DebugAnalyze(GateWay, (uint8_t *)data, strlen(data));
+			/*+LIPURC是模组异步事件: 统一在此分发(升级/业务), 不进AT状态机*/
+			if(strstr(RxBuffTemp, "+LIPURC") != NULL) {
+				CatOneUrcHandle(GateWay, RxBuffTemp);
 			}
+			else {
 				CatOneAtCmdAnalyze(RxBuffTemp);
-			memset(CatOneRxBuff, 0x00, CAT_ONE_REV_LEN_MAX);
+			}
+		memset(CatOneRxBuff, 0x00, CatOneRxLen + 1);
 		}
 	}
 }
@@ -699,10 +730,7 @@ void CatOne_Thread_Entry(void *parameter)
 	rt_kprintf("CatOne Thread is running!\r\n");

 	while(1) {
-		if(!ChannelIsActive(GateWay->ConfigPara, CH_CAT1)) {
-			rt_thread_delay(100);
-			continue;
-		}
+		/*USART1专用Cat1: 上电即持续注网连接, 不再依赖通道配置*/
 		CatOneLoopHandler();
 	}
 }
@@ -712,7 +740,7 @@ void Cat1IrqCallback(uint8_t rData)
 	if(Cat1RevTimeOutCnt == 0)
 		CatOneRxLen = 0;

-	if(CatOneRxLen < CAT_ONE_REV_LEN_MAX) {
+	if(CatOneRxLen < CAT_ONE_URC_LEN_MAX) {
 		CatOneRxBuff[CatOneRxLen++] = rData;
 	}

@@ -749,3 +777,4 @@ void CatOneTriggerRegister(void)
 	CAT1_ON();
 	CatOneReset();
 }
+
@@ -297,7 +297,7 @@ static void EthRev_Thread_Entry(void *parameter)
 			memcpy(RxBuffTemp, EthRxBuff, EthRxLen);
 			RxBuffTemp[EthRxLen] = 0;
 			memset(HexData, 0x00, EthRxLen / 2);
-			uint8_t ret = AsciiToHex(RxBuffTemp, HexData, EthRxLen);
+			uint16_t ret = AsciiToHex(RxBuffTemp, HexData, EthRxLen);
 			if(ret > 0 && HexData[0] == 0x7A) {
 				Eth.SendNoDataCnt = 0;
 				if(GateWay->ConfigPara.Much == CH_ETH)
@@ -126,7 +126,7 @@ void HexToAscii(uint8_t *HexData, char *ASCData, uint8_t sLen)
 						sLen, 需要转的字符串长度
 * 返 回 值: 无
 *****************************************************************************************/
-uint8_t AsciiToHex(char *ASCData, uint8_t *HexData, uint8_t sLen)
+uint16_t AsciiToHex(char *ASCData, uint8_t *HexData, uint16_t sLen)
 {
 	char chr;
 	uint8_t HexLen = 0;
@@ -64,4 +64,361 @@ void UpdateInit(void)
 	}
 }

+/*****************************************************************************************
+*                          Cat1远程升级模块(0x7D帧, 与Boot RS485升级协议一致)
+* 服务器(升级主机) --TCP--> Cat1模组 --USART1--> 本模块:
+* 收0x81升级请求(校验/擦暂存区/断点续传判定) → 0x82分包顺序写入外部SPI Flash暂存区
+* → 每收NUP_WINDOW包回0x02请求帧(服务端窗口流控) → 收完CRC32校验通过后置
+* APP_UPDATE_SPI_FLAG复位, 由Boot完成"外部Flash→B区→A区"搬运
+* 协议帧: 0x7D + DevMac(6) + Cmd + Len + Payload + CRC16(Modbus), 命令0x81/0x82/0x01/0x02
+*****************************************************************************************/
+#define NUP_PACKET_DATA			200				//每包数据长度(与服务端/Boot一致)
+#define NUP_STASH_PROG_MAGIC	0xA5A5C35A		//升级进度记录魔数
+#define NUP_WINDOW				8				//每收W包回一次请求帧
+#define NUP_TIMEOUT_MS			3000			//等包超时(Cat1延迟大)
+#define NUP_TIMEOUT_MAX			5				//连续超时次数上限
+#define NUP_IDLE_TIMEOUT_MS		1800000UL		//整体无进展超时(30分钟)
+#define NUP_FRAME_BUF_MAX		3072			//0x7D组帧缓冲上限(容纳URC单次喂入的多帧拼接)
+#define NUP_APP_MAX				(232 * 1024)	//A区容量上限

+/*升级进度记录(存外部Flash扇区4037): 断电/断连后据此判定断点续传*/
+typedef struct {
+	uint32_t Magic;			//NUP_STASH_PROG_MAGIC
+	uint32_t AppSize;		//固件大小
+	uint32_t Crc32;			//固件CRC32
+	uint32_t PkgCnt;		//已连续收到的包数
+}FwStashProg_t;
+
+static struct {
+	bool     Active;		//升级会话进行中
+	uint16_t PkgCnt;		//总包数
+	uint32_t AppSize;		//固件大小
+	uint32_t Crc32;			//固件CRC32
+	uint16_t ExpectIdx;		//期望接收的包序号
+	uint16_t LastAckIdx;	//最近一次0x02应答的包序号(窗口流控基准)
+	uint32_t LastTick;		//最近收包时刻(rt_tick, 1ms)
+	uint32_t ErrCnt;		//连续超时次数
+	uint8_t  TxQ[4][40];	//应答帧队列(0x01/0x02连发互不挤占)
+	uint8_t  TxQLen[4];
+	uint8_t  TxHead;		//队首索引(出队)
+	uint8_t  TxCnt;			//队列帧数
+}Nup;
+
+static uint8_t  NupFrameBuf[NUP_FRAME_BUF_MAX];		//0x7D组帧缓冲(TCP分片跨URC拼接)
+static uint16_t NupFrameLen = 0;
+
+/*软件CRC32: 与Boot GetCrc32/服务端zlib.crc32同算法(0xEDB88320反射, 初末值0xFFFFFFFF)*/
+static uint32_t NetUpgradeCrc32Stash(uint32_t Len)
+{
+	uint32_t Crc = 0xFFFFFFFF;
+	uint32_t Done = 0;
+	uint8_t Buf[256];
+	while(Done < Len) {
+		uint16_t n = (Len - Done > sizeof(Buf)) ? sizeof(Buf) : (uint16_t)(Len - Done);
+		FwStashRead(Buf, Done, n);
+		for(uint16_t i = 0; i < n; i++) {
+			Crc ^= Buf[i];
+			for(int b = 0; b < 8; b++) {
+				Crc = (Crc & 1) ? (Crc >> 1) ^ 0xEDB88320 : (Crc >> 1);
+			}
+		}
+		Done += n;
+	}
+	return ~Crc;
+}
+
+/*进度记录持久化(扇区4037): PkgCnt=0表示清除*/
+static void NetUpgradeSaveProg(uint32_t PkgCnt)
+{
+	FwStashProg_t Prog;
+	Prog.Magic = (PkgCnt > 0) ? NUP_STASH_PROG_MAGIC : 0;
+	Prog.AppSize = Nup.AppSize;
+	Prog.Crc32 = Nup.Crc32;
+	Prog.PkgCnt = PkgCnt;
+	FwStashProgWrite((uint8_t *)&Prog, sizeof(Prog));
+}
+
+/*待发帧入队(0x7D原始帧, 由CatOne主循环经AT+LIPSEND直发, 绕过0x7A打包)*/
+static void NetUpgradePushTx(uint8_t Cmd, uint8_t *Payload, uint8_t Len)
+{
+	uint16_t crc;
+	if(Nup.TxCnt >= 4) {
+		return;		//队列满(正常时序最多2帧, 满则丢弃)
+	}
+	uint8_t Tail = (Nup.TxHead + Nup.TxCnt) % 4;
+	Nup.TxQ[Tail][0] = 0x7D;
+	memcpy(&Nup.TxQ[Tail][1], GateWay.ConfigPara.GwMac, 6);
+	Nup.TxQ[Tail][7] = Cmd;
+	Nup.TxQ[Tail][8] = Len;
+	memcpy(&Nup.TxQ[Tail][9], Payload, Len);
+	crc = CRC_Modbus(CRC16_BASE, Nup.TxQ[Tail], 9 + Len);
+	Nup.TxQ[Tail][9 + Len] = crc & 0xFF;
+	Nup.TxQ[Tail][10 + Len] = (crc >> 8) & 0xFF;
+	Nup.TxQLen[Tail] = 11 + Len;
+	Nup.TxCnt++;
+}
+
+static void NetUpgradeSendAck(uint8_t Status, uint16_t Resumed)
+{
+	uint8_t p[3];
+	p[0] = Status;
+	p[1] = Resumed & 0xFF;
+	p[2] = (Resumed >> 8) & 0xFF;
+	NetUpgradePushTx(0x01, p, 3);		//0x20全新/0x21续传/0x32拒绝
+}
+
+static void NetUpgradeSendReq(uint16_t Idx)
+{
+	uint8_t p[4];
+	p[0] = Idx & 0xFF;
+	p[1] = (Idx >> 8) & 0xFF;
+	p[2] = Nup.PkgCnt & 0xFF;
+	p[3] = (Nup.PkgCnt >> 8) & 0xFF;
+	NetUpgradePushTx(0x02, p, 4);		//请求从Idx起的下一批(收满PkgCnt视为完成)
+}
+
+/*0x81升级请求: 合法性检查/断点续传判定/擦暂存区/回ACK并启动下载*/
+static void NetUpgradeOnReq(uint8_t *Payload, uint8_t Len)
+{
+	UpDataRequset_t Req;
+	uint32_t Resumed = 0;
+	if(Len < sizeof(Req)) {
+		return;
+	}
+	memcpy(&Req, Payload, sizeof(Req));
+	if(Req.AppSize == 0 || Req.AppSize > NUP_APP_MAX) {
+		NetUpgradeSendAck(0x32, 0);
+		U_DBG_LOG("NetUpgrade reject: AppSize=%d\r\n", Req.AppSize);
+		return;
+	}
+	if(Nup.Active && Nup.AppSize == Req.AppSize && Nup.Crc32 == Req.AppCrc32) {
+		Resumed = Nup.ExpectIdx;		//同会话重复0x81: 内存进度优先
+	}
+	else {
+		FwStashProg_t Prog;
+		FwStashProgRead((uint8_t *)&Prog, sizeof(Prog));
+		if(Prog.Magic == NUP_STASH_PROG_MAGIC && Prog.AppSize == Req.AppSize
+			&& Prog.Crc32 == Req.AppCrc32 && Prog.PkgCnt > 0 && Prog.PkgCnt < Req.PackageNum) {
+			Resumed = Prog.PkgCnt;		//断电/断连后断点续传
+		}
+		else {
+			FwStashEraseAll();			//全新升级: 擦暂存区
+			NetUpgradeSaveProg(0);
+		}
+		Nup.Active = true;
+		Nup.PkgCnt = Req.PackageNum;
+		Nup.AppSize = Req.AppSize;
+		Nup.Crc32 = Req.AppCrc32;
+		Nup.ExpectIdx = Resumed;
+		Nup.ErrCnt = 0;
+		Nup.LastTick = rt_tick_get();
+	}
+	Nup.LastAckIdx = Resumed;
+	U_DBG_LOG("NetUpgrade req: Pkg=%d Size=%d Crc=0x%08x Resumed=%d\r\n",
+		Nup.PkgCnt, Nup.AppSize, Nup.Crc32, Resumed);
+	NetUpgradeSendAck(Resumed > 0 ? 0x21 : 0x20, Resumed);
+	NetUpgradeSendReq(Resumed);			//ACK后主动请求首包, 服务端收到0x02才开始发包
+}
+
+/*0x82升级数据: 严格按期望包号顺序写暂存区, 收满窗口回请求帧, 收完CRC校验*/
+static void NetUpgradeOnData(uint8_t *Payload, uint8_t Len)
+{
+	uint16_t Idx, Total;
+	uint8_t DataLen;
+	uint32_t WriteLen;
+	if(!Nup.Active || Len < 5) {
+		return;
+	}
+	Idx = Payload[0] | (Payload[1] << 8);
+	Total = Payload[2] | (Payload[3] << 8);
+	DataLen = Payload[4];
+	if(Total != Nup.PkgCnt) {
+		return;							//会话不匹配
+	}
+	if(Idx != Nup.ExpectIdx) {
+		return;							//重复/乱序包: 丢弃(服务端按期望包号重发)
+	}
+	if(Idx == Nup.PkgCnt - 1) {
+		WriteLen = Nup.AppSize - (uint32_t)Idx * NUP_PACKET_DATA;	//尾包实长
+		if(DataLen < WriteLen) {
+			return;
+		}
+	}
+	else {
+		if(DataLen < NUP_PACKET_DATA) {
+			return;
+		}
+		WriteLen = NUP_PACKET_DATA;
+	}
+	FwStashWrite(&Payload[5], (uint32_t)Idx * NUP_PACKET_DATA, WriteLen);
+	Nup.ExpectIdx++;
+	Nup.LastTick = rt_tick_get();
+	Nup.ErrCnt = 0;
+	if(Nup.ExpectIdx >= Nup.PkgCnt) {
+		if(NetUpgradeCrc32Stash(Nup.AppSize) == Nup.Crc32) {
+			U_DBG_LOG("NetUpgrade stash verified, reboot to bootloader\r\n");
+			UpdateFromStash(Nup.AppSize, Nup.Crc32);	//置APP_UPDATE_SPI_FLAG并复位
+		}
+		U_DBG_LOG("NetUpgrade stash CRC failed, restart download\r\n");
+		FwStashEraseAll();				//校验失败: 擦暂存从头重下
+		NetUpgradeSaveProg(0);
+		Nup.ExpectIdx = 0;
+		NetUpgradeSendReq(0);
+		return;
+	}
+	if(Nup.ExpectIdx - Nup.LastAckIdx >= NUP_WINDOW) {
+		NetUpgradeSendReq(Nup.ExpectIdx);	//收满窗口, 请求下一批(与断点起点无关)
+		Nup.LastAckIdx = Nup.ExpectIdx;
+	}
+	if(Nup.ExpectIdx % (NUP_WINDOW * 4) == 0) {
+		NetUpgradeSaveProg(Nup.ExpectIdx);	//定期持久化进度(32包一次)
+	}
+}
+
+static void NetUpgradeFrameHandler(uint8_t Cmd, uint8_t *Payload, uint8_t Len)
+{
+		U_DBG_LOG("NetUpgrade frame: cmd=0x%02x len=%d\r\n", Cmd, Len);
+	switch(Cmd) {
+		case 0x81:
+			NetUpgradeOnReq(Payload, Len);
+			break;
+		case 0x82:
+			NetUpgradeOnData(Payload, Len);
+			break;
+		default:
+			break;
+	}
+}
+
+/*****************************************************************************************
+* 函数名称: NetUpgradeFeed
+* 功能描述: 喂入Cat1下行数据片段(+LIPURC二进制), 流式拼接提取完整0x7D升级帧
+* 参    数: data/len, 二进制数据片段(TCP分片有序)
+* 返 回 值: true=数据已被升级模块消费(帧头0x7D); false=非0x7D流, 调用方交还原0x7A路径
+*****************************************************************************************/
+bool NetUpgradeFeed(uint8_t *data, uint16_t len)
+{
+	if(NupFrameLen == 0) {
+		uint16_t skip = 0;
+		while(skip < len && data[skip] != 0x7D) {
+			skip++;
+		}
+		if(skip >= len) {
+			return false;
+		}
+		data += skip;
+		len -= skip;
+	}
+	if(NupFrameLen + len > NUP_FRAME_BUF_MAX) {
+		NupFrameLen = 0;				//溢出保护, 重新同步
+		return true;
+	}
+	memcpy(&NupFrameBuf[NupFrameLen], data, len);
+	NupFrameLen += len;
+	while(NupFrameLen >= 11) {
+		if(NupFrameBuf[0] != 0x7D) {
+			uint16_t i;
+			for(i = 1; i < NupFrameLen; i++) {
+				if(NupFrameBuf[i] == 0x7D) break;
+			}
+			if(i >= NupFrameLen) {
+				NupFrameLen = 0;
+				break;
+			}
+			memmove(NupFrameBuf, &NupFrameBuf[i], NupFrameLen - i);
+			NupFrameLen -= i;
+			continue;
+		}
+		uint16_t total = 11 + NupFrameBuf[8];
+		if(NupFrameLen < total) {
+			break;						//帧未收齐, 等下一分片
+		}
+		uint16_t calc = CRC_Modbus(CRC16_BASE, NupFrameBuf, total - 2);
+		uint16_t recv = NupFrameBuf[total - 2] | (NupFrameBuf[total - 1] << 8);
+		if(calc == recv) {
+			NetUpgradeFrameHandler(NupFrameBuf[7], &NupFrameBuf[9], NupFrameBuf[8]);
+			memmove(NupFrameBuf, &NupFrameBuf[total], NupFrameLen - total);
+			NupFrameLen -= total;
+		}
+		else {
+			memmove(NupFrameBuf, &NupFrameBuf[1], NupFrameLen - 1);
+			NupFrameLen -= 1;
+		}
+	}
+	return true;
+}
+
+/*****************************************************************************************
+* 函数名称: NetUpgradePopTx
+* 功能描述: 取待发应答帧(0x01 ACK/0x02请求), 由CatOne主循环经AT+LIPSEND直发
+*****************************************************************************************/
+bool NetUpgradePopTx(uint8_t *Out, uint16_t *OutLen)
+{
+	if(Nup.TxCnt == 0) {
+		return false;
+	}
+	memcpy(Out, Nup.TxQ[Nup.TxHead], Nup.TxQLen[Nup.TxHead]);
+	*OutLen = Nup.TxQLen[Nup.TxHead];
+	Nup.TxHead = (Nup.TxHead + 1) % 4;
+	Nup.TxCnt--;
+	return true;
+}
+
+bool NetUpgradeActive(void)
+{
+	return Nup.Active;
+}
+
+/*****************************************************************************************
+* 函数名称: NetUpgradeTick
+* 功能描述: 1ms轮询(CatOne主循环调用): 等包超时催发请求, 长期无进展放弃会话
+*****************************************************************************************/
+void NetUpgradeTick(void)
+{
+	if(!Nup.Active) {
+		if(NupFrameLen > 0) {
+			NupFrameLen = 0;		/*非会话期清理残片, 防止后续0x7A业务流被组帧器吞掉*/
+		}
+		return;
+	}
+	uint32_t Now = rt_tick_get();
+	if(Now - Nup.LastTick > NUP_IDLE_TIMEOUT_MS) {
+		Nup.Active = false;
+		NupFrameLen = 0;
+		U_DBG_LOG("NetUpgrade idle timeout(30min), abort session\r\n");
+		return;
+	}
+	if(Now - Nup.LastTick > NUP_TIMEOUT_MS) {
+		Nup.LastTick = Now;
+		NupFrameLen = 0;		/*等包超时: 残片必为损坏流, 清掉重同步*/
+		Nup.ErrCnt++;
+		if(Nup.ErrCnt > NUP_TIMEOUT_MAX) {
+			Nup.Active = false;			//放弃会话(不复位), 服务器可重新0x81发起
+			NupFrameLen = 0;
+			U_DBG_LOG("NetUpgrade timeout, abort session\r\n");
+			return;
+		}
+		NetUpgradeSendReq(Nup.ExpectIdx);	//催发: 服务端重发当前批次
+	}
+}
+
+/*****************************************************************************************
+* 函数名称: UpdateFromStash
+* 功能描述: 暂存区校验通过后, 置APP_UPDATE_SPI_FLAG并复位, Boot从外部Flash搬运升级
+*****************************************************************************************/
+void UpdateFromStash(uint32_t AppSize, uint32_t Crc32)
+{
+	boot_para_t cfg;
+
+	READ_BOOT_PARA(&cfg);
+	cfg.AppSize = AppSize;
+	cfg.Crc32Check = Crc32;
+	cfg.PackageCnt = (uint16_t)((AppSize + NUP_PACKET_DATA - 1) / NUP_PACKET_DATA);
+	cfg.AppFlag = 0;
+	cfg.UpdateFlag = APP_UPDATE_SPI_FLAG;
+
+	U_DBG_LOG("Upgrade ready: Size=%d Crc=0x%08x, reboot\r\n", AppSize, Crc32);
+	SAVE_BOOT_PARA(&cfg);
+	U_DELAY_MS(200);
+	U_SYSTEM_TESET();
+}
@@ -400,9 +400,14 @@ static void RS485Ch1UsartErrIrqCallback(void)
 * 参    数: 无
 * 返 回 值: 无
 *****************************************************************************************/
+static volatile bool RS485Ch1TxFlag = false;	/*RS485Ch1发送期间置位: RX中断丢弃回环自收字节*/
+
 static void RS485Ch1UsartRxIrqCallback(void)
 {
 	uint8_t rData = RS485Ch1UartRec();
+	if(RS485Ch1TxFlag) {
+		return;	/*发送回环自收字节丢弃*/
+	}
 	RS485Ch1RxIrqCallback(rData);
 }

@@ -502,11 +507,13 @@ void RS485Ch1_Config(uint32_t BaudRate)
 void RS485Ch1UartSend(uint8_t *sData, uint16_t sLen)
 {
 	RS485_CH1_TX();
+	RS485Ch1TxFlag = true;
 	for(int i = 0; i < sLen; i++) {
 		USART_SendData(RS485_CH1_USART_CH, sData[i]);
 		while(USART_GetStatus(RS485_CH1_USART_CH, UsartTxComplete) == Reset);
 	}
 	RS485_CH1_RX();
+	RS485Ch1TxFlag = false;
 }

 /*****************************************************************************************
@@ -285,10 +285,10 @@ void GateWayInit(void)
 	}
 	else
 		rt_kprintf("History Num: 0\r\n");
-	bool cat1Active = ChannelIsActive(GateWay.ConfigPara, CH_CAT1);
+	/*USART1专用Cat1: 上电恒115200+CAT1方向, 调试输出统一走RS485 Ch1(见rt_hw_console_output)*/
 	bool ethActive  = ChannelIsActive(GateWay.ConfigPara, CH_ETH);
-	if(cat1Active) { DbgOrCat1Uart_Config(115200); CAT1_ON(); }
-	else { DBG_ON(); DbgOrCat1Uart_Config(500000); }
+	DbgOrCat1Uart_Config(115200);
+	CAT1_ON();
 	if(ethActive) { ETH_ON(); rt_thread_delay(1000); ETHReset(); }
 }

@@ -323,7 +323,7 @@ void CheckDelSecter(uint32_t wAddr, uint16_t wLen)
 	uint32_t DelSectorNum = 0;
 	uint32_t SurplusSpace = SPIFLASH_SECTORSIZE - (wAddr % SPIFLASH_SECTORSIZE);
 	
-	if((wAddr + wLen) > SPIFLASH_SIZE) {
+	if((wAddr + wLen) > LOG_SAV_END_ADDR) {
 		DelOffsetAddr = LOG_SAV_START_SECTOR * SPIFLASH_SECTORSIZE;
 		SetLastLogEndAddr(DelOffsetAddr + wLen);
 		SetLoopSavFlag(1);
@@ -342,7 +342,7 @@ void CheckDelSecter(uint32_t wAddr, uint16_t wLen)
 			SpiFlashEraseSector(DelOffsetAddr);
 			DelOffsetAddr += SPIFLASH_SECTORSIZE;
 		}
-		if(DelOffsetAddr == SPIFLASH_SIZE) {
+		if(DelOffsetAddr == LOG_SAV_END_ADDR) {
 			DelOffsetAddr = LOG_SAV_START_SECTOR * SPIFLASH_SECTORSIZE;
 		}
 		FindFirstLogAddr = DelOffsetAddr;
@@ -363,7 +363,7 @@ void CheckDelSecter(uint32_t wAddr, uint16_t wLen)
 		}
 		if(i == LOG_SAV_SIZE_MAX) {
 			ReadAddr += LOG_SAV_SIZE_MAX;
-			if(ReadAddr >= SPIFLASH_SIZE) {		//找不到下一条数据，重置flash
+			if(ReadAddr >= LOG_SAV_END_ADDR) {		//找不到下一条数据，重置flash
 				Debug_Printf("Add LOG Error, Next Data No Find!\r\n");
 				SetLogNum(0);
 				SetLoopSavFlag(0);
@@ -407,7 +407,7 @@ void AddLog(uint8_t *wData, uint32_t wLen)
 	
 	//判断是否跨扇区，跨扇区需要先擦除下一扇区
 	CheckDelSecter(LLEndAddr, LogSize);
-	if(LogH->LogEndAddr > SPIFLASH_SIZE) {
+	if(LogH->LogEndAddr > LOG_SAV_END_ADDR) {
 		LLEndAddr = LOG_SAV_START_SECTOR * SPIFLASH_SECTORSIZE;
 		LogH->LogEndAddr = ReadLastLogEndAddr();
 	}
@@ -419,6 +419,61 @@ void AddLog(uint8_t *wData, uint32_t wLen)
 }


+/*升级进度记录读写(扇区4037): 记录AppSize/Crc32/已收包数, 断电断连后支持断点续传*/
+void FwStashProgRead(uint8_t *rData, uint16_t rLen)
+{
+	FlashLock();
+	SpiFlashReadAnyLengthData(rData, FLASH_FW_STASH_PROG_SECTOR * SPIFLASH_SECTORSIZE, rLen);
+	FlashUnlock();
+}
+
+void FwStashProgWrite(uint8_t *wData, uint16_t wLen)
+{
+	FlashLock();
+	SpiFlashEraseSector(FLASH_FW_STASH_PROG_SECTOR * SPIFLASH_SECTORSIZE);
+	SpiFlashWriteAnyLengthData(wData, FLASH_FW_STASH_PROG_SECTOR * SPIFLASH_SECTORSIZE, wLen);
+	FlashUnlock();
+}
+
+/*固件升级暂存区操作: 内部带互斥, 避免与AddLog/WritePara的SPI事务交错*/
+void FwStashEraseAll(void)
+{
+	FlashLock();
+	for(int i = 0; i < FLASH_FW_STASH_SECTORS; i++) {
+		SpiFlashEraseSector(FLASH_FW_STASH_SECTOR * SPIFLASH_SECTORSIZE + i * SPIFLASH_SECTORSIZE);
+	}
+	FlashUnlock();
+}
+
+void FwStashEraseSector(uint32_t SectorIdx)
+{
+	FlashLock();
+	SpiFlashEraseSector(FLASH_FW_STASH_SECTOR * SPIFLASH_SECTORSIZE + SectorIdx * SPIFLASH_SECTORSIZE);
+	FlashUnlock();
+}
+
+int FwStashWrite(uint8_t *wData, uint32_t Offset, uint16_t wLen)
+{
+	if(Offset + wLen > FLASH_FW_STASH_SECTORS * SPIFLASH_SECTORSIZE) {
+		return -1;
+	}
+	FlashLock();
+	SpiFlashWriteAnyLengthData(wData, FLASH_FW_STASH_SECTOR * SPIFLASH_SECTORSIZE + Offset, wLen);
+	FlashUnlock();
+	return 0;
+}
+
+int FwStashRead(uint8_t *rData, uint32_t Offset, uint16_t rLen)
+{
+	if(Offset + rLen > FLASH_FW_STASH_SECTORS * SPIFLASH_SECTORSIZE) {
+		return -1;
+	}
+	FlashLock();
+	SpiFlashReadAnyLengthData(rData, FLASH_FW_STASH_SECTOR * SPIFLASH_SECTORSIZE + Offset, rLen);
+	FlashUnlock();
+	return 0;
+}
+
 /*****************************************************************************************
 * 函数名称: ReadLog
 * 功能描述: 读取日志