hc_fun.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2022-12-21 19813 the first version
  9. */
  10. /*********************↓ define ↓************************/
  11. #define HC_Addr 0xFE
  12. #define HC_BuffSize 30
  13. #define One 100
  14. #define Zero 200
  15. /*********************↑ define ↑************************/
  16. /**
  17. *
  18. *
  19. *
  20. *
  21. * */
  22. /*********************↓ include ↓************************/
  23. #include "sys_config.h"
  24. #include "hc_fun.h"
  25. /*********************↑ include ↑************************/
  26. /**
  27. *
  28. *
  29. *
  30. *
  31. * */
  32. /*********************↓ extern ↓************************/
  33. extern uint32_t hour;
  34. extern uint32_t min;
  35. extern uint32_t sec;
  36. extern rt_device_t dtu_serial;
  37. extern Sector qxz;
  38. extern void rs485_send_data(uint8_t *data, uint8_t len);
  39. extern uint16_t CRC16_Modbus(uint8_t *_pBuf, uint16_t _usLen);
  40. /*********************↑ extern ↑************************/
  41. /**
  42. *
  43. *
  44. *
  45. *
  46. * */
  47. /*********************↓ global variables ↓************************/
  48. //static uint8_t HC_BuffSize = 30;
  49. static uint8_t HC_TxBuff[HC_BuffSize] = {0};
  50. static uint8_t HC_RxBuff[HC_BuffSize] = {0};
  51. /*********************↑ global variables ↑************************/
  52. /**
  53. *
  54. *
  55. *
  56. *
  57. * */
  58. /*********************↓ declaration ↓************************/
  59. /*********************↑ declaration ↑************************/
  60. /**
  61. *
  62. *
  63. *
  64. *
  65. * */
  66. ///
  67. /// 为航插对时
  68. ///
  69. /// 发送格式 FE 10 0006 0003 06 hour min sec CRCH CRCL
  70. ///
  71. /// 回复格式 FE 10 0006 0003 CRCH CRCL
  72. ///
  73. /// 例:FE 10 0006 0003 06 0010 0020 0000 92 68
  74. ///
  75. ///
  76. /**
  77. * @brief 向航插板对时
  78. *
  79. * @return HC_RES
  80. */
  81. HC_RES HC_CalibrationTime(void)
  82. {
  83. uint8_t res = HC_OK;
  84. uint16_t crc = 0;
  85. uint8_t send_size = 0;
  86. //rt_kprintf("HC_CalibrationTime\n");
  87. memset(HC_TxBuff, 0, HC_BuffSize);
  88. memset(HC_RxBuff, 0, HC_BuffSize);
  89. HC_TxBuff[send_size++] = HC_Addr;
  90. HC_TxBuff[send_size++] = 0x10;
  91. HC_TxBuff[send_size++] = 00;
  92. HC_TxBuff[send_size++] = 07;
  93. HC_TxBuff[send_size++] = 00;
  94. HC_TxBuff[send_size++] = 03;
  95. HC_TxBuff[send_size++] = 06;
  96. HC_TxBuff[send_size++] = (hour >> 8);
  97. HC_TxBuff[send_size++] = (hour & 0xFF);
  98. HC_TxBuff[send_size++] = (min >> 8);
  99. HC_TxBuff[send_size++] = (min & 0xFF);
  100. HC_TxBuff[send_size++] = (sec >> 8);
  101. HC_TxBuff[send_size++] = (sec & 0xFF);
  102. crc = CRC16_Modbus(HC_TxBuff, send_size);
  103. HC_TxBuff[send_size++] = crc >> 8;
  104. HC_TxBuff[send_size++] = crc & 0xFF;
  105. rs485_send_data(HC_TxBuff, send_size);
  106. res = HC_CheckReturn(6);
  107. return res;
  108. }
  109. ///
  110. ///
  111. /// 运行模式设置
  112. ///
  113. /// 发送格式 FE 06 00 00 00 64 CRCH CRCL
  114. ///
  115. /// 回复格式 FE 06 00 00 00 64 CRCH CRCL
  116. ///
  117. ///
  118. ///
  119. /**
  120. * @brief 设置运行模式
  121. *
  122. * @param mode One/Zero 低功耗/正常
  123. * @return HC_RES
  124. */
  125. HC_RES HC_SetRunMode(void)
  126. {
  127. /**
  128. *LED点阵屏使能标志
  129. * 0:不使用LED点阵屏
  130. * 1:控制卡型号5K1
  131. * 2:控制卡型号5K2
  132. * 3:控制卡型号5K3
  133. *
  134. * 5:Y1A-1DP-1Bit
  135. * 6:Y1A-1DP-8Bit
  136. * 7:Y1A-2DP-1Bit
  137. * 8:Y1A-2DP-8Bit
  138. *
  139. */
  140. //rt_kprintf("HC_SetRunMode\n");
  141. uint8_t res = HC_OK;
  142. uint16_t crc = 0;
  143. uint8_t send_size = 0;
  144. uint8_t mode = One;
  145. if (qxz.Param.Dotled_Option > 8)
  146. {
  147. return HC_ParaErr;
  148. }
  149. // rt_kprintf("control card %d\n", qxz.Param.Dotled_Option);
  150. if (qxz.Param.Dotled_Option == 0)
  151. {
  152. mode = One;
  153. }
  154. else
  155. {
  156. mode = Zero;
  157. }
  158. memset(HC_TxBuff, 0, HC_BuffSize);
  159. memset(HC_RxBuff, 0, HC_BuffSize);
  160. HC_TxBuff[send_size++] = HC_Addr;
  161. HC_TxBuff[send_size++] = 0x06;
  162. HC_TxBuff[send_size++] = 00;
  163. HC_TxBuff[send_size++] = 00;
  164. HC_TxBuff[send_size++] = 00;
  165. HC_TxBuff[send_size++] = mode;
  166. crc = CRC16_Modbus(HC_TxBuff, send_size);
  167. HC_TxBuff[send_size++] = crc >> 8;
  168. HC_TxBuff[send_size++] = crc & 0xFF;
  169. rs485_send_data(HC_TxBuff, send_size);
  170. res = HC_CheckReturn(6);
  171. return res;
  172. }
  173. ///
  174. ///
  175. /// 上报时间间隔设置
  176. ///
  177. /// 发送格式 FE 06 00 02 00 data CRCH CRCL
  178. ///
  179. /// 回复格式 FE 06 00 02 00 data CRCH CRCL
  180. ///
  181. ///
  182. /**
  183. * @brief 设置上报间隔
  184. *
  185. * @return HC_RES
  186. */
  187. HC_RES HC_SetInterval(void)
  188. {
  189. //rt_kprintf("HC_SetInterval\n");
  190. uint8_t res = HC_OK;
  191. uint16_t crc = 0;
  192. uint8_t send_size = 0;
  193. if (qxz.Param.upload_interval < 2)
  194. {
  195. return HC_ParaErr;
  196. }
  197. memset(HC_TxBuff, 0, HC_BuffSize);
  198. memset(HC_RxBuff, 0, HC_BuffSize);
  199. HC_TxBuff[send_size++] = HC_Addr;
  200. HC_TxBuff[send_size++] = 0x06;
  201. HC_TxBuff[send_size++] = 00;
  202. HC_TxBuff[send_size++] = 02;
  203. HC_TxBuff[send_size++] = 00;
  204. HC_TxBuff[send_size++] = qxz.Param.upload_interval;
  205. crc = CRC16_Modbus(HC_TxBuff, send_size);
  206. HC_TxBuff[send_size++] = crc >> 8;
  207. HC_TxBuff[send_size++] = crc & 0xFF;
  208. rs485_send_data(HC_TxBuff, send_size);
  209. res = HC_CheckReturn(6);
  210. return res;
  211. }
  212. ///
  213. ///
  214. /// 上报等待时间设置
  215. ///
  216. /// 发送格式 FE 06 00 03 data CRCH CRCL
  217. ///
  218. /// 发送格式 FE 06 00 03 data CRCH CRCL
  219. ///
  220. ///
  221. /**
  222. * @brief 设置上报后等待时长
  223. *
  224. * @param duration 分钟数 不可大于interval
  225. * @return HC_RES
  226. */
  227. HC_RES HC_SetWaitTime(void)
  228. {
  229. uint8_t duration = 0;
  230. uint8_t res = HC_OK;
  231. uint16_t crc = 0;
  232. uint8_t send_size = 0;
  233. //rt_kprintf("HC_SetWaitTime\n");
  234. duration = qxz.Param.upload_interval / 3;
  235. if (qxz.Param.upload_interval < duration || duration == 0)
  236. {
  237. //rt_kprintf("return HC_ParaErr\n");
  238. return HC_ParaErr;
  239. }
  240. memset(HC_TxBuff, 0, HC_BuffSize);
  241. memset(HC_RxBuff, 0, HC_BuffSize);
  242. HC_TxBuff[send_size++] = HC_Addr;
  243. HC_TxBuff[send_size++] = 0x06;
  244. HC_TxBuff[send_size++] = 00;
  245. HC_TxBuff[send_size++] = 03;
  246. HC_TxBuff[send_size++] = 00;
  247. HC_TxBuff[send_size++] = duration;
  248. crc = CRC16_Modbus(HC_TxBuff, send_size);
  249. HC_TxBuff[send_size++] = crc >> 8;
  250. HC_TxBuff[send_size++] = crc & 0xFF;
  251. rs485_send_data(HC_TxBuff, send_size);
  252. res = HC_CheckReturn(6);
  253. return res;
  254. }
  255. ///
  256. /// 单次等待时间设置
  257. ///
  258. /// 发送格式 FE 06 00 04 data CRCH CRCL
  259. ///
  260. /// 发送格式 FE 06 00 04 data CRCH CRCL
  261. ///
  262. ///
  263. /**
  264. * @brief 设置单次等待时长
  265. *
  266. * @param duration 分钟数
  267. * @return HC_RES
  268. */
  269. HC_RES HC_SetOnecWaitTime(uint8_t duration)
  270. {
  271. //rt_kprintf("HC_SetOnecWaitTime\n");
  272. uint8_t res = HC_OK;
  273. uint16_t crc = 0;
  274. uint8_t send_size = 0;
  275. if (duration == 0 || duration > 15)
  276. {
  277. return HC_ParaErr;
  278. }
  279. memset(HC_TxBuff, 0, HC_BuffSize);
  280. memset(HC_RxBuff, 0, HC_BuffSize);
  281. HC_TxBuff[send_size++] = HC_Addr;
  282. HC_TxBuff[send_size++] = 0x06;
  283. HC_TxBuff[send_size++] = 00;
  284. HC_TxBuff[send_size++] = 04;
  285. HC_TxBuff[send_size++] = 00;
  286. HC_TxBuff[send_size++] = duration;
  287. crc = CRC16_Modbus(HC_TxBuff, send_size);
  288. HC_TxBuff[send_size++] = crc >> 8;
  289. HC_TxBuff[send_size++] = crc & 0xFF;
  290. rs485_send_data(HC_TxBuff, send_size);
  291. res = HC_CheckReturn(6);
  292. return res;
  293. }
  294. /**
  295. * @brief 检查返回数据
  296. *
  297. * @param check_len 校验长度
  298. * @return HC_RES 校验结果
  299. */
  300. HC_RES HC_CheckReturn(uint8_t check_len)
  301. {
  302. uint16_t cnt = 0;
  303. uint8_t res = HC_OK;
  304. rt_thread_mdelay(900);
  305. if (rt_device_read(dtu_serial, 0, &HC_RxBuff, HC_BuffSize) > 0)
  306. {
  307. //rt_kprintf("recv return ->");
  308. for (uint8_t a = 0; a < check_len; a++)
  309. {
  310. // rt_kprintf("%02X ",HC_RxBuff[a]);
  311. if (HC_TxBuff[a] == HC_RxBuff[a])
  312. {
  313. cnt++;
  314. }
  315. }
  316. // rt_kprintf("\n");
  317. }
  318. if (cnt != check_len)
  319. {
  320. res = HC_ERROR;
  321. }
  322. // rt_kprintf("check cnt %d\n",cnt);
  323. memset(HC_TxBuff, 0, HC_BuffSize);
  324. memset(HC_RxBuff, 0, HC_BuffSize);
  325. return res;
  326. }
  327. ///
  328. ///
  329. /// 上报时间间隔设置
  330. ///
  331. /// 发送格式 FE 06 00 02 00 data CRCH CRCL
  332. ///
  333. /// 回复格式 FE 06 00 02 00 data CRCH CRCL
  334. ///
  335. ///
  336. /**
  337. * @brief 设置休眠时保留供电
  338. *
  339. * @param Reserve_PWR 位号
  340. * @return HC_RES 结果
  341. */
  342. HC_RES HC_Set_Reserve_PWR(uint8_t Reserve_PWR)
  343. {
  344. //rt_kprintf("HC_Set_Reserve_PWR\n");
  345. uint8_t res = HC_OK;
  346. uint16_t crc = 0;
  347. uint8_t send_size = 0;
  348. memset(HC_TxBuff, 0, HC_BuffSize);
  349. memset(HC_RxBuff, 0, HC_BuffSize);
  350. HC_TxBuff[send_size++] = HC_Addr;
  351. HC_TxBuff[send_size++] = 0x06;
  352. HC_TxBuff[send_size++] = 00;
  353. HC_TxBuff[send_size++] = 06;
  354. HC_TxBuff[send_size++] = 00;
  355. HC_TxBuff[send_size++] = Reserve_PWR;
  356. crc = CRC16_Modbus(HC_TxBuff, send_size);
  357. HC_TxBuff[send_size++] = crc >> 8;
  358. HC_TxBuff[send_size++] = crc & 0xFF;
  359. rs485_send_data(HC_TxBuff, send_size);
  360. res = HC_CheckReturn(6);
  361. return res;
  362. }
  363. /**
  364. * @brief 检查返回数据
  365. *
  366. * @param check_len 校验长度
  367. * @return HC_RES 数据结果
  368. */
  369. HC_RES HC_GetReturn(uint8_t check_len)
  370. {
  371. uint16_t cnt = 0;
  372. uint8_t res = HC_OK;
  373. uint16_t crc16 = 0;
  374. rt_thread_mdelay(500);
  375. if (rt_device_read(dtu_serial, 0, &HC_RxBuff, check_len) > 0)
  376. {
  377. if (CRC16_Modbus(HC_RxBuff, 5) == 0xADC6)
  378. {
  379. res = HC_0;
  380. }
  381. if (CRC16_Modbus(HC_RxBuff, 5) == 0xADBB)
  382. {
  383. res = HC_1;
  384. }
  385. }
  386. memset(HC_TxBuff, 0, HC_BuffSize);
  387. memset(HC_RxBuff, 0, HC_BuffSize);
  388. //rt_kprintf("HC_GetReturn > %d\n", res);
  389. return res;
  390. }
  391. ///
  392. ///
  393. /// 获取开机类型
  394. ///
  395. /// 发送格式 FE 03 00 07 00 01 21 C4
  396. ///
  397. /// 回复格式 FE 03 02 00 C8 AD C6
  398. ///
  399. ///
  400. /**
  401. * @brief 读取本次开机类型
  402. *
  403. * @return HC_RES 结果 (0 正常开机 1 周期开机)
  404. */
  405. HC_RES HC_Get_PWSta(void)
  406. {
  407. //rt_kprintf("HC_Set_Reserve_PWR\n");
  408. uint8_t res = HC_OK;
  409. uint16_t crc = 0;
  410. uint8_t send_size = 0;
  411. memset(HC_TxBuff, 0, HC_BuffSize);
  412. memset(HC_RxBuff, 0, HC_BuffSize);
  413. HC_TxBuff[send_size++] = HC_Addr;
  414. HC_TxBuff[send_size++] = 03;
  415. HC_TxBuff[send_size++] = 00;
  416. HC_TxBuff[send_size++] = 07;
  417. HC_TxBuff[send_size++] = 00;
  418. HC_TxBuff[send_size++] = 01;
  419. crc = CRC16_Modbus(HC_TxBuff, send_size);
  420. HC_TxBuff[send_size++] = crc >> 8;
  421. HC_TxBuff[send_size++] = crc & 0xFF;
  422. rs485_send_data(HC_TxBuff, send_size);
  423. res = HC_GetReturn(6);
  424. return res;
  425. }