rtu.c 23 KB

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