rtu.c 25 KB

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