rtu.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987
  1. #include "rtu.h"
  2. #include "para.h"
  3. #include "main.h"
  4. #include "usart.h"
  5. #include "pm.h"
  6. #include "rtu.h"
  7. #include "usart.h"
  8. #include "w25qxx.h"
  9. #include "crc.h"
  10. #include "rec.h"
  11. #include "string.h"
  12. #include "app_rtc.h"
  13. #include "sensor.h"
  14. #include "ymodem.h"
  15. #define diff_abs(a, b) ((a > b) ? (a - b) : (b - a))
  16. #define CMD_STATUS_REQ 0x01 // 状态查询
  17. #define CMD_UPLOAD_REC 0x02 // 上传记录
  18. #define CMD_TIME_SYNC 0x03 // 校时
  19. #define CMD_PARA_SYNC 0x04 // 参数同步
  20. #define CMD_GET_REALTIME 0x05 // 获取实时数据
  21. #define CMD_POWERDOWN_NOTICE 0x06 // 通知即将掉电
  22. #define CMD_OTA_START 0x07 // 本地串口 YMODEM 升级
  23. typedef enum
  24. {
  25. RTU_STA_IDLE,
  26. RTU_STA_GET_STATUS,
  27. RTU_STA_CHK_ONLINE,
  28. RTU_STA_CHK_PARA,
  29. RTU_STA_CHK_OTA,
  30. RTU_STA_TIME_SYNC,
  31. RTU_STA_SND_REC,
  32. RTU_STA_WAIT_RESP,
  33. RTU_STA_WAIT_READY,
  34. RTU_STA_NOTYIFY_POWER_DOWN
  35. } rtu_sta_t;
  36. struct
  37. {
  38. uint8_t trig_src; // 0:计划 1:按键
  39. rtu_sta_t tsk_sta;
  40. rtu_sta_t next_sta;
  41. uint8_t last_cmd;
  42. uint32_t running_timer; // 总运行时间定时器
  43. uint32_t tsk_timer;
  44. uint32_t tsk_tmo;
  45. int rx_len;
  46. uint32_t rx_timer;
  47. uint8_t rx_buf[128];
  48. int key_wakeup;
  49. int online;
  50. int ota_ongoing;
  51. int time_syncd;
  52. int ota_chked;
  53. int para_chked;
  54. int photo_ongoing;
  55. int rec_ongoing;
  56. uint8_t power_down_ongoing;
  57. uint8_t power_down_cnt; // 切断rtu电源的倒计时,单位秒
  58. uint8_t ota_need_reset; // OTA 升级完成后待复位标志
  59. struct
  60. {
  61. uint16_t count;
  62. uint16_t index[24];
  63. } rec_pack;
  64. } rtu_ctx;
  65. static uint8_t rtu_last_wakeup_hour = 0;
  66. void rtu_init(uint8_t trig_src)
  67. {
  68. if (pm_get_lock("rtu") < 0)
  69. {
  70. return;
  71. }
  72. memset(&rtu_ctx, 0, sizeof(rtu_ctx));
  73. MX_USART2_UART_Init();
  74. LL_USART_EnableIT_RXNE(COM_RTU);
  75. // 打开电源
  76. HAL_GPIO_WritePin(PWR_RTU_GPIO_Port, PWR_RTU_Pin, GPIO_PIN_SET);
  77. rtu_ctx.running_timer = HAL_GetTick();
  78. // 暂时不处理ota
  79. rtu_ctx.ota_chked = 1;
  80. rtu_ctx.ota_ongoing = 0;
  81. rtu_ctx.tsk_sta = RTU_STA_GET_STATUS;
  82. rtu_ctx.trig_src = trig_src;
  83. rtu_ctx.key_wakeup = trig_src;
  84. rtu_ctx.ota_need_reset = 0;
  85. }
  86. void rtu_deinit(void)
  87. {
  88. // 关闭rtu电源
  89. HAL_GPIO_WritePin(PWR_RTU_GPIO_Port, PWR_RTU_Pin, GPIO_PIN_RESET);
  90. // 关闭所使用到的外设
  91. LL_USART_DisableIT_RXNE(COM_RTU);
  92. LL_USART_DeInit(COM_RTU);
  93. LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_USART2);
  94. // 串口输入设置为模拟输入
  95. LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
  96. GPIO_InitStruct.Pin = LL_GPIO_PIN_2 | LL_GPIO_PIN_3;
  97. GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
  98. LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  99. // 释放功耗锁
  100. pm_release_lock("rtu");
  101. rtu_ctx.tsk_sta = RTU_STA_IDLE;
  102. rtu_ctx.key_wakeup = 0;
  103. }
  104. static void rtu_write(uint8_t *buf, int sz)
  105. {
  106. if (sz)
  107. {
  108. for (int i = 0; i < sz; i++)
  109. {
  110. LL_USART_TransmitData8(COM_RTU, buf[i]);
  111. while (!LL_USART_IsActiveFlag_TC(COM_RTU))
  112. ;
  113. }
  114. }
  115. }
  116. static int rtu_escape_data(uint8_t *src, int src_len, uint8_t *dst, int dst_size)
  117. {
  118. int dst_len = 0;
  119. for (int i = 0; i < src_len && dst_len < dst_size - 1; i++)
  120. {
  121. if (src[i] == 0x7E)
  122. {
  123. if (dst_len + 2 <= dst_size)
  124. {
  125. *dst++ = 0x7D;
  126. *dst++ = 0x5E;
  127. dst_len += 2;
  128. }
  129. else
  130. {
  131. return -1; // 不足空间进行转义
  132. }
  133. }
  134. else if (src[i] == 0x7D)
  135. {
  136. if (dst_len + 2 <= dst_size)
  137. {
  138. *dst++ = 0x7D;
  139. *dst++ = 0x5D;
  140. dst_len += 2;
  141. }
  142. else
  143. {
  144. return -1; // 不足空间进行转义
  145. }
  146. }
  147. else
  148. {
  149. *dst++ = src[i];
  150. dst_len++;
  151. }
  152. }
  153. return dst_len;
  154. }
  155. int rtu_send_pkt(uint8_t addr, uint8_t cmd, uint8_t *msg, uint16_t len)
  156. {
  157. uint8_t buf[512];
  158. uint8_t escaped_buf[512];
  159. uint16_t crc;
  160. int escaped_len;
  161. int data_len = 0;
  162. buf[data_len++] = addr;
  163. buf[data_len++] = cmd;
  164. if (len && msg)
  165. {
  166. memcpy(buf + data_len, msg, len);
  167. data_len += len;
  168. }
  169. crc = CRC16(buf, data_len);
  170. buf[data_len++] = crc & 0xFF;
  171. buf[data_len++] = crc >> 8;
  172. // 对帧头和帧尾之间的所有数据进行转义
  173. escaped_len = rtu_escape_data(buf, data_len, escaped_buf, sizeof(escaped_buf));
  174. if (escaped_len < 0)
  175. {
  176. return -1;
  177. }
  178. int frame_len = 0;
  179. buf[frame_len++] = 0x7D;
  180. memcpy(buf + frame_len, escaped_buf, escaped_len);
  181. frame_len += escaped_len;
  182. buf[frame_len++] = 0x7E;
  183. rtu_write(buf, frame_len);
  184. rtu_ctx.last_cmd = cmd;
  185. return 0;
  186. }
  187. int rtu_read(uint8_t *buf, int sz, int *len)
  188. {
  189. if (rtu_ctx.rx_len > 0)
  190. {
  191. int deltT = HAL_GetTick() - rtu_ctx.rx_timer;
  192. if (deltT > 20)
  193. {
  194. *len = rtu_ctx.rx_len;
  195. if (*len > sz)
  196. {
  197. *len = sz;
  198. }
  199. memcpy(buf, (void *)rtu_ctx.rx_buf, rtu_ctx.rx_len);
  200. rtu_ctx.rx_len = 0;
  201. return 0;
  202. }
  203. }
  204. return 1;
  205. }
  206. void rtu_parse_sta(uint32_t sta)
  207. {
  208. rtu_ctx.online = (sta & 0x01) ? 1 : 0;
  209. rtu_ctx.ota_ongoing = (sta & 0x02) ? 1 : 0;
  210. rtu_ctx.photo_ongoing = (sta & 0x0c) >> 2;
  211. rtu_ctx.rec_ongoing = (sta & 0x30) >> 4;
  212. }
  213. void rtu_pack_rec(uint8_t *buf, int sz)
  214. {
  215. uint16_t start_index = 0;
  216. rec_data_t rec;
  217. rtu_ctx.rec_pack.count = 0;
  218. if (!buf)
  219. {
  220. return;
  221. }
  222. for (int i = 0; i < RECORD_MAX_COUNT; i++)
  223. {
  224. if ((rtu_ctx.rec_pack.count + 1) * sizeof(rec_data_t) > sz)
  225. {
  226. break;
  227. }
  228. if (rec_read(start_index, &rtu_ctx.rec_pack.index[rtu_ctx.rec_pack.count], &rec) == 0)
  229. {
  230. uint8_t *p = &buf[sizeof(rec_data_t) * rtu_ctx.rec_pack.count];
  231. *p++ = rec.timestamp >> 24;
  232. *p++ = rec.timestamp >> 16;
  233. *p++ = rec.timestamp >> 8;
  234. *p++ = rec.timestamp;
  235. *p++ = rec.temperature >> 8;
  236. *p++ = rec.temperature;
  237. *p++ = rec.humidity >> 8;
  238. *p++ = rec.humidity;
  239. *p++ = rec.illuminance >> 24;
  240. *p++ = rec.illuminance >> 16;
  241. *p++ = rec.illuminance >> 8;
  242. *p++ = rec.illuminance;
  243. *p++ = rec.voltage >> 8;
  244. *p++ = rec.voltage;
  245. start_index = rtu_ctx.rec_pack.index[rtu_ctx.rec_pack.count] + 1;
  246. rtu_ctx.rec_pack.count++;
  247. }
  248. else
  249. {
  250. break;
  251. }
  252. }
  253. }
  254. static int rtu_unescape_data(const uint8_t *src, int src_len, uint8_t *dst, int dst_size)
  255. {
  256. const uint8_t *src_end = src + src_len;
  257. uint8_t *dst_start = dst;
  258. uint8_t *dst_end = dst + dst_size;
  259. while (src < src_end && dst < dst_end)
  260. {
  261. uint8_t byte = *src++;
  262. if (byte == 0x7D)
  263. {
  264. if (src < src_end)
  265. {
  266. byte = *src++;
  267. if (byte == 0x5E)
  268. {
  269. byte = 0x7E;
  270. }
  271. else if (byte == 0x5D)
  272. {
  273. byte = 0x7D;
  274. }
  275. else
  276. {
  277. return -1; // 无效的转义序列
  278. }
  279. }
  280. else
  281. {
  282. return -1; // 转义字符后面没有数据
  283. }
  284. }
  285. *dst++ = byte;
  286. }
  287. return dst - dst_start;
  288. }
  289. // 发送一条实时记录
  290. static void rtu_send_realtime_data(void)
  291. {
  292. uint8_t ack[14];
  293. sensor_data_t data;
  294. rtc_time_t time;
  295. uint32_t timestamp;
  296. rtc_get_time(&time);
  297. timestamp = rtc_mktime(&time);
  298. sensor_get_data(&data);
  299. data.voltage = data.voltage;
  300. ack[0] = timestamp >> 24;
  301. ack[1] = timestamp >> 16;
  302. ack[2] = timestamp >> 8;
  303. ack[3] = timestamp;
  304. ack[4] = data.temperature >> 8;
  305. ack[5] = data.temperature;
  306. ack[6] = data.humidity >> 8;
  307. ack[7] = data.humidity;
  308. ack[8] = data.illuminance >> 24;
  309. ack[9] = data.illuminance >> 16;
  310. ack[10] = data.illuminance >> 8;
  311. ack[11] = data.illuminance;
  312. ack[12] = data.voltage >> 8;
  313. ack[13] = data.voltage;
  314. rtu_send_pkt(1, 0x05, ack, 14);
  315. }
  316. int rtu_rx_proc(uint8_t *buf, int len)
  317. {
  318. int processed = 0;
  319. while (len > 0)
  320. {
  321. // 查找帧头0x7D
  322. int frame_start = -1;
  323. for (int i = 0; i < len; i++)
  324. {
  325. if (buf[i] == 0x7D)
  326. {
  327. if (i + 1 < len)
  328. {
  329. if (buf[i + 1] == 0x5E || buf[i + 1] == 0x5D)
  330. {
  331. i++;
  332. continue;
  333. }
  334. }
  335. frame_start = i;
  336. break;
  337. }
  338. }
  339. if (frame_start < 0)
  340. {
  341. break;
  342. }
  343. if (frame_start > 0)
  344. {
  345. buf += frame_start;
  346. len -= frame_start;
  347. }
  348. if (len < 6)
  349. {
  350. break;
  351. }
  352. // 查找帧尾 0x7E
  353. int frame_end = -1;
  354. for (int i = 1; i < len; i++)
  355. {
  356. if (buf[i] == 0x7E)
  357. {
  358. frame_end = i;
  359. break;
  360. }
  361. }
  362. if (frame_end < 0)
  363. {
  364. break;
  365. }
  366. // 提取完整帧进行处理
  367. int frame_len = frame_end + 1;
  368. // 检查帧长度有效性
  369. if (frame_len < 6)
  370. {
  371. buf += frame_len;
  372. len -= frame_len;
  373. continue;
  374. }
  375. // 将已经转义的字节恢复
  376. uint8_t unescaped_buf[frame_len - 2]; // 不包括起始符和结束符
  377. int unescaped_len = rtu_unescape_data(buf + 1, frame_len - 2, unescaped_buf, sizeof(unescaped_buf));
  378. if (unescaped_len < 0)
  379. {
  380. // 解转义错误,跳过此帧继续处理
  381. buf += frame_len;
  382. len -= frame_len;
  383. continue;
  384. }
  385. // CRC校验
  386. if (CRC16(unescaped_buf, unescaped_len) != 0)
  387. {
  388. buf += frame_len;
  389. len -= frame_len;
  390. continue;
  391. }
  392. if (unescaped_buf[1] == rtu_ctx.last_cmd)
  393. {
  394. rtu_ctx.tsk_tmo = 0;
  395. }
  396. switch (unescaped_buf[1])
  397. {
  398. case 0x01: // 状态应答
  399. case 0x06: // 掉电通知的应答
  400. {
  401. if (unescaped_len >= 6)
  402. {
  403. uint32_t sta;
  404. sta = (uint32_t)(unescaped_buf[2] << 24 | unescaped_buf[3] << 16 |
  405. unescaped_buf[4] << 8 | unescaped_buf[5]);
  406. rtu_parse_sta(sta);
  407. }
  408. }
  409. break;
  410. case 0x02: // 记录上传的应答
  411. // 记录上传成功,删除已经发送的记录
  412. for (int i = 0; i < rtu_ctx.rec_pack.count; i++)
  413. {
  414. rec_delete(rtu_ctx.rec_pack.index[i]);
  415. }
  416. break;
  417. case 0x03: // 校时应答
  418. {
  419. if (unescaped_len >= 6)
  420. {
  421. uint32_t server_time, local_time;
  422. rtc_time_t time;
  423. server_time = (uint32_t)(unescaped_buf[2] << 24 | unescaped_buf[3] << 16 |
  424. unescaped_buf[4] << 8 | unescaped_buf[5]);
  425. rtc_get_time(&time);
  426. local_time = rtc_mktime(&time);
  427. // 根据服务器时间校准本机时间
  428. if (diff_abs(server_time, local_time) > 2)
  429. {
  430. rtc_gmtime(&time, server_time);
  431. rtc_set_time(&time);
  432. }
  433. rtu_ctx.time_syncd = 1;
  434. }
  435. }
  436. break;
  437. case 0x04: // 参数同步请求的应答
  438. {
  439. if (unescaped_len >= 7)
  440. {
  441. uint32_t para_ver;
  442. // 获取4字节参数版本号,大端模式
  443. para_ver = (uint32_t)((unescaped_buf[2] << 24) | (unescaped_buf[3] << 16) |
  444. (unescaped_buf[4] << 8) | unescaped_buf[5]);
  445. if (para_ver != para.ver ||
  446. para.mode != unescaped_buf[6] ||
  447. para.light_mode_hours != unescaped_buf[7] ||
  448. para.time_mode_start != unescaped_buf[8] ||
  449. para.time_mode_end != unescaped_buf[9] ||
  450. para.photo_interval != ((uint16_t)unescaped_buf[10] << 8) + unescaped_buf[11])
  451. {
  452. // 获取新的参数
  453. para.ver = para_ver;
  454. para.mode = unescaped_buf[6];
  455. if (unescaped_len >= 8)
  456. para.light_mode_hours = unescaped_buf[7];
  457. if (unescaped_len >= 9)
  458. para.time_mode_start = unescaped_buf[8];
  459. if (unescaped_len >= 10)
  460. para.time_mode_end = unescaped_buf[9];
  461. if (unescaped_len >= 12)
  462. para.photo_interval = ((uint16_t)unescaped_buf[10] << 8) + unescaped_buf[11];
  463. para_write(&para);
  464. }
  465. rtu_ctx.para_chked = 1;
  466. }
  467. }
  468. break;
  469. case 0x05: // RTU获取实时数据的请求
  470. {
  471. rtu_send_realtime_data();
  472. break;
  473. }
  474. case CMD_OTA_START: // RTU YMODEM 升级相关
  475. {
  476. /*
  477. * 升级响应帧示例:7D 01 07 00 22 30 7E
  478. * unescaped_buf[0] = addr = 0x01
  479. * unescaped_buf[1] = cmd = 0x07 (CMD_OTA_START)
  480. * unescaped_buf[2] = flag = 0x00 / 0x01
  481. * 0x00:不升级(当前版本为最新)
  482. * 0x01:需要升级,随后走 YMODEM 传输
  483. * unescaped_buf[3..] = CRC16
  484. */
  485. if (unescaped_len < 3)
  486. {
  487. // 长度不够,直接丢弃
  488. break;
  489. }
  490. uint8_t ota_flag = unescaped_buf[2];
  491. // 0x00:不升级,清掉标志后退出
  492. if (ota_flag == 0x00)
  493. {
  494. rtu_ctx.ota_ongoing = 0;
  495. break;
  496. }
  497. // 只接受 0x01 表示“需要升级”,其它值按“不升级”处理
  498. if (ota_flag != 0x01)
  499. {
  500. rtu_ctx.ota_ongoing = 0;
  501. break;
  502. }
  503. // 已经在升级过程中,则不重复进入
  504. if (rtu_ctx.ota_ongoing)
  505. {
  506. break;
  507. }
  508. rtu_ctx.ota_ongoing = 1;
  509. //uint8_t err = 0x01;
  510. //rtu_send_pkt(1, CMD_OTA_START, &err, 1);
  511. // 需要升级:关闭帧接收中断,进入 YMODEM 升级流程
  512. LL_USART_DisableIT_RXNE(COM_RTU);
  513. uint32_t recvSize = 0;
  514. // flashStartAddr = 0,flashMaxSize = 0 表示从 0 开始,直到芯片末尾
  515. int32_t ret = Ymodem_ReceiveToW25Qxx(EXT_FLASH_FW_DATA_ADDR, APP_MAX_SIZE, &recvSize);
  516. if (ret == 0)
  517. {
  518. // recvSize 字节的文件已经从 flash 地址 0 开始存好了
  519. // 这里可以做校验、启动应用、更新标志位等操作
  520. // 标志位写入外部 flash,先擦后写,按扇区擦除
  521. W25qxx_EraseSector(EXT_FLASH_FW_FLAG_ADDR);
  522. W25qxx_WriteByte(0xAA, EXT_FLASH_FW_FLAG_ADDR);
  523. // 文件大小写入外部 flash recvSize(字节数)
  524. // 将 uint32_t 的 4 个字节分别写入
  525. W25qxx_WriteByte((recvSize >> 0) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 0); // 字节0
  526. W25qxx_WriteByte((recvSize >> 8) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 1); // 字节1
  527. W25qxx_WriteByte((recvSize >> 16) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 2); // 字节2
  528. W25qxx_WriteByte((recvSize >> 24) & 0xFF, EXT_FLASH_FW_SIZE_ADDR + 3); // 字节3
  529. // 升级成功:恢复串口接收,并标记“待复位”
  530. LL_USART_EnableIT_RXNE(COM_RTU);
  531. rtu_ctx.ota_ongoing = 0;
  532. rtu_ctx.ota_need_reset = 1;
  533. }
  534. else
  535. {
  536. // 失败:恢复串口帧接收,清除 ota_ongoing 标记
  537. rtu_ctx.ota_ongoing = 0;
  538. LL_USART_EnableIT_RXNE(COM_RTU);
  539. // 可选:把错误码返回给上位机,方便调试
  540. uint8_t err = (uint8_t)(ret & 0xFF);
  541. rtu_send_pkt(1, CMD_OTA_START, &err, 1);
  542. }
  543. break;
  544. }
  545. default:
  546. break;
  547. }
  548. // 移动到下一帧
  549. buf += frame_len;
  550. len -= frame_len;
  551. processed = 1;
  552. }
  553. return processed ? 0 : -1;
  554. }
  555. void rtu_task(void)
  556. {
  557. uint8_t buf[256];
  558. int len;
  559. if (rtu_read(buf, sizeof(buf), &len) == 0)
  560. {
  561. rtu_rx_proc(buf, len);
  562. }
  563. // 最大运行时间检查,解决通讯丢失时无法休眠的问题
  564. if(1)
  565. {
  566. /*
  567. * 如果 RTU 处于拍照 / 升级 / 记录上传等忙状态,
  568. * 则不断刷新 running_timer,避免在这些长任务过程中
  569. * 被 10 分钟超时逻辑误判为“通讯丢失”而强制掉电。
  570. */
  571. if (rtu_ctx.ota_ongoing || rtu_ctx.photo_ongoing || rtu_ctx.rec_ongoing)
  572. {
  573. rtu_ctx.running_timer = HAL_GetTick();
  574. }
  575. if ((HAL_GetTick() - rtu_ctx.running_timer) > RTU_MAX_RUN_TIME)
  576. {
  577. // 如果当前不是正在通知掉电或已经空闲,则强制进入掉电流程
  578. if (rtu_ctx.tsk_sta != RTU_STA_NOTYIFY_POWER_DOWN &&
  579. rtu_ctx.tsk_sta != RTU_STA_IDLE &&
  580. rtu_ctx.power_down_ongoing == 0)
  581. {
  582. rtu_ctx.power_down_cnt = 5;
  583. rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN;
  584. // 清除可能的忙标记
  585. rtu_ctx.rec_ongoing = 0;
  586. rtu_ctx.ota_ongoing = 0;
  587. rtu_ctx.photo_ongoing = 0;
  588. }
  589. }
  590. }
  591. switch (rtu_ctx.tsk_sta)
  592. {
  593. default:
  594. case RTU_STA_IDLE:
  595. rtu_deinit();
  596. break;
  597. case RTU_STA_GET_STATUS:
  598. {
  599. uint8_t reason = rtu_ctx.trig_src&0x7f;
  600. rtu_send_pkt(1, CMD_STATUS_REQ, &reason, 1);
  601. rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP;
  602. rtu_ctx.tsk_timer = HAL_GetTick();
  603. rtu_ctx.tsk_tmo = 1000;
  604. rtu_ctx.next_sta = RTU_STA_CHK_ONLINE;
  605. }
  606. break;
  607. case RTU_STA_CHK_ONLINE:
  608. if (rtu_ctx.online == 0)
  609. {
  610. rtu_ctx.tsk_sta = RTU_STA_GET_STATUS;
  611. }
  612. else
  613. {
  614. rtu_ctx.tsk_sta = RTU_STA_CHK_OTA;
  615. // rtu_ctx.tsk_sta = RTU_STA_CHK_PARA;
  616. // rtu_ctx.para_chked = 0;
  617. }
  618. //rtu_ctx.tsk_sta = RTU_STA_CHK_OTA;
  619. break;
  620. case RTU_STA_CHK_OTA:
  621. {
  622. uint8_t req[5];
  623. req[0] = 0;
  624. req[1] = VERSION_MAJOR;
  625. req[2] = VERSION_MINOR;
  626. req[3] = VERSION_BUILD;
  627. req[4] = VERSION_REVISION;
  628. rtu_send_pkt(1, CMD_OTA_START, req, 5);
  629. rtu_ctx.tsk_sta = RTU_STA_CHK_PARA;
  630. rtu_ctx.para_chked = 0;
  631. }
  632. break;
  633. case RTU_STA_CHK_PARA:
  634. if (rtu_ctx.para_chked == 0)
  635. {
  636. uint8_t req[4];
  637. req[0] = para.ver >> 24;
  638. req[1] = para.ver >> 16;
  639. req[2] = para.ver >> 8;
  640. req[3] = para.ver;
  641. rtu_send_pkt(1, 4, req, 4);
  642. rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP;
  643. rtu_ctx.tsk_timer = HAL_GetTick();
  644. rtu_ctx.tsk_tmo = 1000;
  645. rtu_ctx.next_sta = RTU_STA_TIME_SYNC;
  646. }
  647. else
  648. {
  649. rtu_ctx.tsk_sta = RTU_STA_TIME_SYNC;
  650. }
  651. break;
  652. case RTU_STA_TIME_SYNC:
  653. if (rtu_ctx.time_syncd == 0)
  654. {
  655. uint8_t req[4];
  656. rtc_time_t time;
  657. uint32_t timestamp;
  658. rtc_get_time(&time);
  659. timestamp = rtc_mktime(&time);
  660. // 填充本地时间戳
  661. req[0] = timestamp >> 24;
  662. req[1] = timestamp >> 16;
  663. req[2] = timestamp >> 8;
  664. req[3] = timestamp;
  665. rtu_send_pkt(1, 3, req, 4);
  666. rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP;
  667. rtu_ctx.tsk_timer = HAL_GetTick();
  668. rtu_ctx.tsk_tmo = 1000;
  669. rtu_ctx.next_sta = RTU_STA_SND_REC;
  670. }
  671. else
  672. {
  673. rtu_ctx.tsk_sta = RTU_STA_SND_REC;
  674. }
  675. break;
  676. case RTU_STA_SND_REC:
  677. {
  678. // 按键触发、0点触发时上传记录
  679. if (rtu_ctx.trig_src != 1)
  680. {
  681. if (!sensor_is_busy())
  682. {
  683. // 0点唤醒时,发送24小时记录
  684. if (rtu_ctx.trig_src == 0)
  685. {
  686. uint8_t rec_buf[sizeof(rec_data_t) * 24] = {0};
  687. rtu_pack_rec(rec_buf, sizeof(rec_buf));
  688. if (rtu_ctx.rec_pack.count)
  689. {
  690. rtu_send_pkt(1, 2, rec_buf, sizeof(rec_buf));
  691. rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP;
  692. rtu_ctx.tsk_timer = HAL_GetTick();
  693. rtu_ctx.tsk_tmo = 5000;
  694. rtu_ctx.next_sta = RTU_STA_GET_STATUS;
  695. }
  696. else
  697. {
  698. rtu_ctx.tsk_sta = RTU_STA_WAIT_READY;
  699. }
  700. }
  701. // 按键唤醒时,发送一条实时数据
  702. else if(rtu_ctx.trig_src == 2)
  703. {
  704. rtu_send_realtime_data();
  705. rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP;
  706. rtu_ctx.tsk_timer = HAL_GetTick();
  707. // 延时1S后转到RTU_STA_WAIT_READY状态
  708. rtu_ctx.tsk_tmo = 0;
  709. rtu_ctx.next_sta = RTU_STA_WAIT_READY;
  710. // 250930增加,防止重复上传
  711. rtu_ctx.trig_src |= 0x80;
  712. }
  713. else
  714. {
  715. // 按键唤醒,且已经发送了一条实时数据
  716. rtu_ctx.tsk_sta = RTU_STA_WAIT_READY;
  717. }
  718. }
  719. }
  720. else
  721. {
  722. // 拍照间隔唤醒,不发送记录
  723. rtu_ctx.tsk_sta = RTU_STA_WAIT_READY;
  724. }
  725. }
  726. break;
  727. case RTU_STA_WAIT_READY:
  728. /*
  729. * 按键/手动唤醒(trig_src == 2,或带0x80标记的2):
  730. * 不再根据 RTU 状态应答来决定何时掉电,仅由 RTU_MAX_RUN_TIME
  731. * 的 10 分钟超时逻辑决定何时进入掉电流程。
  732. */
  733. if ( (rtu_ctx.trig_src & 0x7f) == 2 )
  734. {
  735. rtu_ctx.tsk_sta = RTU_STA_GET_STATUS;
  736. // /* 仅在 RTU 报 busy 时继续查询状态,避免提前进入掉电判断 */
  737. // if (rtu_ctx.ota_ongoing || rtu_ctx.photo_ongoing || rtu_ctx.rec_ongoing)
  738. // {
  739. // rtu_ctx.tsk_sta = RTU_STA_GET_STATUS;
  740. // }
  741. }
  742. else
  743. {
  744. if (rtu_ctx.ota_ongoing == 0 && rtu_ctx.photo_ongoing == 0 && rtu_ctx.rec_ongoing == 0)
  745. {
  746. rtc_time_t t;
  747. int is_in_time_window = 0;
  748. rtc_get_time(&t);
  749. // 检查是否在10点的特殊窗口期内(时控模式下也要保留)
  750. if (t.tm_hour == 0x10 && rtu_last_wakeup_hour != 0x10)
  751. {
  752. // 每天10点唤醒时,预留10分钟的窗口期
  753. if ((HAL_GetTick() - rtu_ctx.running_timer) < 10 * 60 * 1000ul)
  754. {
  755. rtu_ctx.tsk_sta = RTU_STA_GET_STATUS;
  756. is_in_time_window = 1;
  757. }
  758. else
  759. {
  760. rtu_ctx.power_down_cnt = 5;
  761. rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN;
  762. rtu_last_wakeup_hour = t.tm_hour;
  763. is_in_time_window = 1;
  764. }
  765. }
  766. // 如果不在10点窗口期,按照原有逻辑处理
  767. if (!is_in_time_window)
  768. {
  769. // 如果是时控模式,检查当前时间是否在设定的时间范围内
  770. if (para.mode == 1)
  771. {
  772. uint32_t now_min = t.tm_hour * 60 + t.tm_min;
  773. uint32_t start_min = para.time_mode_start * 60;
  774. uint32_t end_min = para.time_mode_end * 60 + 59;
  775. uint32_t time_range = 0;
  776. // 处理跨天情况
  777. if (end_min >= start_min)
  778. {
  779. // 不跨天
  780. time_range = (now_min > start_min && now_min <= end_min) ? 1 : 0;
  781. }
  782. else
  783. {
  784. // 跨天情况 (例如 23:00 到 01:00)
  785. time_range = (now_min > start_min || now_min <= end_min) ? 1 : 0;
  786. }
  787. // 如果当前不在时控时间段内,进入掉电流程
  788. if (!time_range)
  789. {
  790. rtu_ctx.power_down_cnt = 5;
  791. rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN;
  792. rtu_last_wakeup_hour = t.tm_hour;
  793. }
  794. else
  795. {
  796. // 如果在时控时间段内,继续执行原逻辑
  797. rtu_ctx.power_down_cnt = 5;
  798. rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN;
  799. rtu_last_wakeup_hour = t.tm_hour;
  800. }
  801. }
  802. else
  803. {
  804. // 光控模式,使用原来的逻辑
  805. rtu_ctx.power_down_cnt = 5;
  806. rtu_ctx.tsk_sta = RTU_STA_NOTYIFY_POWER_DOWN;
  807. rtu_last_wakeup_hour = t.tm_hour;
  808. }
  809. }
  810. }
  811. else
  812. {
  813. rtu_ctx.tsk_sta = RTU_STA_GET_STATUS;
  814. }
  815. }
  816. break;
  817. case RTU_STA_NOTYIFY_POWER_DOWN:
  818. // 250929增加,rtu应答最新的状态,如果检查状态为busy,则返回到状态查询状态
  819. // 解决RTU任务启动延迟的问题
  820. if (rtu_ctx.ota_ongoing || rtu_ctx.photo_ongoing || rtu_ctx.rec_ongoing)
  821. {
  822. rtu_ctx.tsk_sta = RTU_STA_GET_STATUS;
  823. break;
  824. }
  825. rtu_ctx.power_down_ongoing = 1;
  826. if (rtu_ctx.power_down_cnt)
  827. {
  828. rtu_send_pkt(1, 0x06, &rtu_ctx.power_down_cnt, 1);
  829. rtu_ctx.power_down_cnt--;
  830. rtu_ctx.tsk_sta = RTU_STA_WAIT_RESP;
  831. rtu_ctx.tsk_timer = HAL_GetTick();
  832. rtu_ctx.tsk_tmo = 0; // 设置超时时间为0,无论超时或收到应答,都会在1S后回到本状态
  833. rtu_ctx.next_sta = RTU_STA_NOTYIFY_POWER_DOWN;
  834. }
  835. else
  836. {
  837. rtu_ctx.tsk_sta = RTU_STA_IDLE;
  838. }
  839. break;
  840. case RTU_STA_WAIT_RESP:
  841. if (rtu_ctx.tsk_tmo)
  842. {
  843. if (HAL_GetTick() - rtu_ctx.tsk_timer > rtu_ctx.tsk_tmo)
  844. {
  845. // 250930增加通信丢失容错处理:设置online为0,解决窗口期通讯丢失后不掉电的问题
  846. rtu_ctx.online = 0;
  847. rtu_ctx.tsk_sta = RTU_STA_CHK_ONLINE;
  848. }
  849. }
  850. else if (HAL_GetTick() - rtu_ctx.tsk_timer > 1000)
  851. {
  852. rtu_ctx.tsk_sta = rtu_ctx.next_sta;
  853. }
  854. break;
  855. }
  856. /*
  857. * 如果 OTA 升级已经成功完成(ota_need_reset == 1),
  858. * 则在 RTU 不再忙(不拍照、不上传记录、不在 OTA 中)
  859. * 且状态机已经回到空闲 / 掉电流程时,再执行 MCU 复位。
  860. * 这样可以保证:如果升级结束时正处于拍照过程,
  861. * 会等拍照任务结束、RTU 进入空闲后才复位 MCU。
  862. */
  863. if (rtu_ctx.ota_need_reset &&
  864. rtu_ctx.photo_ongoing == 0 &&
  865. rtu_ctx.rec_ongoing == 0 &&
  866. rtu_ctx.ota_ongoing == 0 &&
  867. (rtu_ctx.tsk_sta == RTU_STA_IDLE ||
  868. rtu_ctx.tsk_sta == RTU_STA_NOTYIFY_POWER_DOWN ||
  869. rtu_ctx.tsk_sta == RTU_STA_WAIT_READY))
  870. {
  871. rtu_ctx.ota_need_reset = 0;
  872. HAL_NVIC_SystemReset();
  873. }
  874. }
  875. void rtu_irq_handle(void)
  876. {
  877. if (LL_USART_IsEnabledIT_RXNE(COM_RTU) && LL_USART_IsActiveFlag_RXNE(COM_RTU))
  878. {
  879. uint8_t tmp;
  880. tmp = LL_USART_ReceiveData8(COM_RTU);
  881. if (rtu_ctx.rx_len < sizeof(rtu_ctx.rx_buf))
  882. {
  883. rtu_ctx.rx_buf[rtu_ctx.rx_len] = tmp;
  884. rtu_ctx.rx_len++;
  885. }
  886. rtu_ctx.rx_timer = HAL_GetTick();
  887. }
  888. if (LL_USART_IsActiveFlag_ORE(COM_RTU))
  889. {
  890. LL_USART_ClearFlag_ORE(COM_RTU);
  891. LL_USART_DisableIT_ERROR(COM_RTU);
  892. }
  893. if (LL_USART_IsEnabledIT_TC(COM_RTU) && LL_USART_IsActiveFlag_TC(COM_RTU))
  894. {
  895. LL_USART_ClearFlag_TC(COM_RTU);
  896. LL_USART_DisableIT_TC(COM_RTU);
  897. }
  898. }