devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于rt-thread的udp客户端_rtthread udp

作者：weixin_40725706 | 2024-02-07 21:41:08

赞

踩

rtthread udp
基于rt-thread的udp客户端


本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.

 

环境：

开发环境:MDK5.23

rt-thread版本：2.1.0

lwip版本：1.4.1

单片机型号：stm32f407

phy芯片型号：
说明：
本程序是udp客户端模块。绑定固定端口进行收发。udp接收是一个线程，接收到数据利用邮箱机制推送到其他处理模块。udp发送提供了多种发送接口。

源码：
udp_socket.h 
  1. /**
  2. * Copyright (c), 2015-2025
  3. * @file udp_socket.h
  4. * @brief udp端口头文件
  5. * @author jdh
  6. * @verbatim 
  7. * Change Logs:
  8. * Date           Author       Notes
  9. * 2017-12-22     jdh          新建
  10. * @endverbatim 
  11. */
  12.  
  13. #ifndef _UDP_SOCKET_H_
  14. #define _UDP_SOCKET_H_
  15.  
  16. #include "drivers.h"
  17.  
  18. /**
  19. * @brief 最大注册邮箱数
  20. */
  21.  
  22. #define MAX_NUM_UDP_SOCKET_MAILBOX  10
  23.  
  24. /**
  25. * @brief 接收数据结构.邮箱会推送此结构指针
  26. */
  27.  
  28. struct UdpSocketRx
  29. {
  30.     T_Buffer_Large buffer;
  31.     struct sockaddr_in sockaddr;
  32. };
  33.  
  34. /**
  35. * @brief 模块载入
  36. */
  37.  
  38. void udp_socket_load(void);
  39.  
  40. /**
  41. * @brief 更新服务器信息
  42. */
  43.  
  44. void udp_socket_update_server_info(void);
  45.  
  46. /**
  47. * @brief socket是否工作
  48. * @return true: 工作.false: 不工作
  49. */
  50.  
  51. bool udp_socket_is_work(void);
  52.  
  53. /**
  54. * @brief 发送数据
  55. * @param data:发送数据存放地址
  56. * @param size:发送数据字节数
  57. * @param dst_ip: 目的ip
  58. * @param dst_port: 目的端口
  59. */
  60.  
  61. void udp_socket_tx(uint8_t *data, uint16_t size, char *dst_ip, uint16_t dst_port);
  62.  
  63. /**
  64. * @brief 发送数据
  65. * @param data:发送数据存放地址
  66. * @param size:发送数据字节数
  67. * @param sockaddr: 目的地址
  68. */
  69.  
  70. void udp_socket_tx_sockaddr(uint8_t *data, uint16_t size, struct sockaddr_in sockaddr);
  71.  
  72. /**
  73. * @brief 发送数据给服务器
  74. * @param data:发送数据存放地址
  75. * @param size:发送数据字节数
  76. */
  77.  
  78. void udp_socket_tx_server(uint8_t *data, uint16_t size);
  79.  
  80. /**
  81. * @brief 发送数据给配置服务器
  82. * @note 配置服务器无效则发送给服务器
  83. * @param data:发送数据存放地址
  84. * @param size:发送数据字节数
  85. */
  86.  
  87. void udp_socket_tx_config_server(uint8_t *data, uint16_t size);
  88.  
  89. /**
  90. * @brief 注册邮箱
  91. * @note 接收数据后会推送到此邮箱
  92. * @param mailbox: 邮箱地址
  93. */
  94.  
  95. void udp_socket_register_mailbox(rt_mailbox_t mailbox);
  96.  
  97. /**
  98. * @brief 增加传输层头后发送数据
  99. * @param dst_device: 目标设备类型
  100. * @param data: 发送数据存放地址
  101. * @param size: 发送数据字节数
  102. * @param sockaddr: 目的地址
  103. */
  104.  
  105. void udp_socket_tx_sockaddr_add_trans_head(uint8_t dst_device, uint8_t *data, uint16_t size, struct sockaddr_in sockaddr);
  106.  
  107. /**
  108. * @brief 发送确认帧
  109. * @param dst_device: 目标设备类型
  110. * @param cmd: 确认帧命令字
  111. * @param ack_cmd: 需要确认的命令
  112. * @param sockaddr: 目的地址
  113. */
  114.  
  115. void udp_socket_tx_sockaddr_ack_frame(uint8_t dst_device, uint8_t cmd, uint8_t ack_cmd, struct sockaddr_in sockaddr);
  116.  
  117. /**
  118. * @brief 增加传输层头后发送数据
  119. * @param dst_device: 目标设备类型
  120. * @param data: 发送数据存放地址
  121. * @param size: 发送数据字节数
  122. * @param sockaddr: 目的地址
  123. */
  124.  
  125. void udp_socket_tx_server_add_trans_head(uint8_t dst_device, uint8_t *data, uint16_t size);
  126.  
  127. /**
  128. * @brief 发送确认帧
  129. * @param dst_device: 目标设备类型
  130. * @param cmd: 确认帧命令字
  131. * @param ack_cmd: 需要确认的命令
  132. * @param sockaddr: 目的地址
  133. */
  134.  
  135. void udp_socket_tx_server_ack_frame(uint8_t dst_device, uint8_t cmd, uint8_t ack_cmd);
  136.  
  137. #endif
udp_socket.c 
  1. /**
  2. * Copyright (c), 2015-2025
  3. * @file udp_socket.c
  4. * @brief udp端口主文件
  5. * @author jdh
  6. * @verbatim 
  7. * Change Logs:
  8. * Date           Author       Notes
  9. * 2017-12-22     jdh          新建
  10. * 2017-12-26     jdh          增加网络和lwip功能
  11. * @endverbatim 
  12. */
  13.  
  14. #include "framework.h"
  15. #include "stm32f4xx_eth.h"
  16. #include <netif/ethernetif.h>
  17.  
  18. #define TAG                     "LOG_UDP"
  19.  
  20. /**
  21. * @brief 配置帧超时时间.单位:ms.超过这个时间,射频模块的回复就不会再发向配置服务器
  22. */
  23.  
  24. #define CONFIG_TIMEOUT          500
  25.  
  26. /**
  27. * @brief 启动稳定期.单位:ms
  28. */
  29.  
  30. #define STARTUP_WAIT_TIME       1000
  31.  
  32. /**
  33. * @brief 日志项编号
  34. */
  35.  
  36. static uint8_t _log_item = 0;
  37.  
  38. static int _socket;
  39. static bool _is_net_work = false;
  40. static struct sockaddr_in _server_addr;
  41. static struct UdpSocketRx _udp_socket_rx;
  42.  
  43. /**
  44. * @brief 配置服务器的地址
  45. */
  46.  
  47. static struct sockaddr_in _config_server_addr;
  48. static T_Time _last_config_frame_time;
  49.  
  50. /**
  51. * @brief 邮箱数组
  52. */
  53.  
  54. static struct rt_mailbox *_mailbox_array[MAX_NUM_UDP_SOCKET_MAILBOX];
  55. static uint8_t _len_mailbox_array = 0;
  56.  
  57. /**
  58. * @brief 发送数据
  59. */
  60.  
  61. static T_Buffer_Large Buffer_Tx;
  62.  
  63. static void thread_init(void* parameter);
  64. static void init_lwip(void);
  65. static void set_ip(void);
  66. static void bind_socket(void);
  67. static void socket_rx(void);
  68. static bool is_frame_valid(void);
  69. static inline void send_mailbox(void);
  70.  
  71. /**
  72. * @brief 模块载入
  73. */
  74.  
  75. void udp_socket_load(void)
  76. {
  77.     _log_item = log_register(TAG);
  78.     
  79. #ifdef RT_USING_LWIP
  80.     rt_thread_t tid_init = rt_thread_create("init_net",
  81. 										thread_init, (void*)0,
  82. 										THREAD_STACK_NORMAL, THREAD_PRIORITY_NORMAL, THREAD_SLICE_NORMAL);
  83. 	rt_thread_startup(tid_init);
  84. #endif
  85. }
  86.  
  87. static void thread_init(void* parameter)
  88. {   
  89.     init_lwip();
  90.     udp_socket_update_server_info();
  91.     bind_socket();
  92.     socket_rx();
  93. }
  94.  
  95. static void init_lwip(void)
  96. {
  97.     /* LwIP Initialization */
  98.     {
  99.         extern void lwip_sys_init(void);
  100.  
  101.         /* register ethernetif device */
  102.         eth_system_device_init();
  103.  
  104. //        rt_hw_stm32_eth_init();
  105.         rt_hw_stm32_eth_init_my();
  106.  
  107.         /* init lwip system */
  108.         lwip_sys_init();
  109.         rt_kprintf("TCP/IP initialized!\n");
  110.     }
  111.     
  112.     set_ip();
  113. }
  114.  
  115. static void set_ip(void)
  116. {
  117.     set_if("e0", para_manage_read_ip(), para_manage_read_gateway(), para_manage_read_mask());
  118.     set_dns(para_manage_read_dns());
  119. }
  120.  
  121. /**
  122. * @brief 更新服务器信息
  123. */
  124.  
  125. void udp_socket_update_server_info(void)
  126. {
  127.     _server_addr.sin_family = AF_INET;
  128. 	_server_addr.sin_port = htons(para_manage_read_server_port());
  129. 	
  130. 	struct hostent *host;
  131. 	host = (struct hostent *)gethostbyname(para_manage_read_server_ip());
  132. 	_server_addr.sin_addr = *((struct in_addr *)host->h_addr);
  133. 	rt_memset(&(_server_addr.sin_zero), 0, sizeof(_server_addr.sin_zero));
  134. }
  135.  
  136. static void bind_socket(void)
  137. {
  138.     struct sockaddr_in local_addr;
  139.     
  140.     // 创建socket
  141.     if ((_socket = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
  142.     {
  143.         log_w(_log_item, "socket error\n");
  144.         // todo
  145.         return;
  146.     }
  147.     
  148.     // 初始化本地地址
  149.     local_addr.sin_family = AF_INET;
  150.     local_addr.sin_port = htons(para_manage_read_port());
  151.     local_addr.sin_addr.s_addr = INADDR_ANY;
  152.     rt_memset(&(local_addr.sin_zero), 0, sizeof(local_addr.sin_zero));
  153.     
  154.     // 绑定端口
  155.     if (bind(_socket, (struct sockaddr *)&local_addr, sizeof(struct sockaddr)) == -1)
  156.     {
  157.         log_w(_log_item, "Bind error\n");
  158.         // todo 
  159.         return;
  160.     }
  161.     
  162.     thread_delay(STARTUP_WAIT_TIME);
  163.     _is_net_work = true;
  164. }
  165.  
  166. static void socket_rx(void)
  167. {
  168.     rt_uint32_t addr_len;
  169.     
  170.     addr_len = sizeof(struct sockaddr);
  171.     
  172.     while (1)
  173. 	{
  174.         _udp_socket_rx.buffer.len = recvfrom(_socket, 
  175.                                              _udp_socket_rx.buffer.buf, 
  176.                                              LEN_BUFFER_LARGE - 1, 
  177.                                              0, (struct sockaddr *)&_udp_socket_rx.sockaddr, &addr_len);
  178.         
  179.         if (is_frame_valid())
  180.         {   
  181.             log_i(_log_item, "udp rx ip:%s port:%02d\n", inet_ntoa(_udp_socket_rx.sockaddr.sin_addr.s_addr), 
  182.                                                      ntohs(_udp_socket_rx.sockaddr.sin_port));
  183.             
  184.             if (_udp_socket_rx.buffer.buf[PTH_DST_DEVICE_POS] == DEVICE_STATION)
  185.             {
  186.                 // 发送给本机
  187.                 send_mailbox();
  188.             }
  189.             else
  190.             {
  191.                 // 转发
  192.                 uart_tx(_udp_socket_rx.buffer.buf[PTH_ADDITIONAL_POS], _udp_socket_rx.buffer.buf, _udp_socket_rx.buffer.len);
  193.                 
  194.                 // 保存配置服务器信息
  195.                 if (_udp_socket_rx.buffer.buf[PTH_DST_DEVICE_POS] == DEVICE_TIME_MODULE || 
  196.                     _udp_socket_rx.buffer.buf[PTH_DST_DEVICE_POS] == DEVICE_RADIO_MODULE)
  197.                 {
  198.                     _config_server_addr = _udp_socket_rx.sockaddr;
  199.                     _last_config_frame_time = get_local_time();
  200.                 }
  201.             }
  202.             
  203.             led_blink(LED_RX_NET);
  204.             log_add_num_rx_udp_frame();
  205.         }
  206. 	}
  207. }
  208.  
  209. static bool is_frame_valid(void)
  210. {
  211.     if (_udp_socket_rx.buffer.len < PTH_LEN_FRAME_HEAD)
  212.     {
  213.         return false;
  214.     }
  215.     
  216.     uint16_t frame_head = (_udp_socket_rx.buffer.buf[PTH_LEN_FRAME_HEAD_POS] << 8) +
  217.                            _udp_socket_rx.buffer.buf[PTH_LEN_FRAME_HEAD_POS + 1];
  218.     if (frame_head != PTH_HEAD)
  219.     {
  220.         return false;
  221.     }
  222.     
  223.     uint16_t body_len = (_udp_socket_rx.buffer.buf[PTH_BODY_LEN_POS] << 8) + _udp_socket_rx.buffer.buf[PTH_BODY_LEN_POS + 1];
  224.     if (_udp_socket_rx.buffer.len != body_len + PTH_LEN_FRAME_HEAD)
  225.     {
  226.         return false;
  227.     }
  228.     
  229.     if (_udp_socket_rx.buffer.buf[PTH_ADDITIONAL_POS] > MODULE_NUM)
  230.     {
  231.         return false;
  232.     }
  233.     
  234.     uint16_t crc_get = (_udp_socket_rx.buffer.buf[PTH_BODY_CRC_POS] << 8) + _udp_socket_rx.buffer.buf[PTH_BODY_CRC_POS + 1];
  235.     uint16_t crc_calc = crc_code(_udp_socket_rx.buffer.buf + PTH_LEN_FRAME_HEAD, body_len);
  236.     if (crc_get != crc_calc)
  237.     {
  238.         return false;
  239.     }
  240.     
  241.     return true;
  242. }
  243.  
  244. static inline void send_mailbox(void)
  245. {   
  246.     for (uint8_t i = 0; i < _len_mailbox_array; i++)
  247.     {
  248.         rt_mb_send(_mailbox_array[i], (rt_uint32_t)&_udp_socket_rx);
  249.     }
  250. }
  251.  
  252. /**
  253. * @brief socket是否工作
  254. * @return true: 工作.false: 不工作
  255. */
  256.  
  257. bool udp_socket_is_work(void)
  258. {
  259.     return _is_net_work;
  260. }
  261.  
  262. /**
  263. * @brief 发送数据
  264. * @param data:发送数据存放地址
  265. * @param size:发送数据字节数
  266. * @param dst_ip: 目的ip
  267. * @param dst_port: 目的端口
  268. */
  269.  
  270. void udp_socket_tx(uint8_t *data, uint16_t size, char *dst_ip, uint16_t dst_port)
  271. {
  272.     if (!_is_net_work)
  273.     {
  274.         return;
  275.     }
  276.     
  277.     struct sockaddr_in remote_addr;
  278.     
  279.     remote_addr.sin_family = AF_INET;
  280. 	remote_addr.sin_port = htons(dst_port);
  281. 	
  282. 	struct hostent *host;
  283. 	host = (struct hostent *)gethostbyname(dst_ip);
  284. 	remote_addr.sin_addr = *((struct in_addr *)host->h_addr);
  285. 	rt_memset(&(remote_addr.sin_zero), 0, sizeof(remote_addr.sin_zero));
  286. 	
  287. 	sendto(_socket, data, size, 0, (struct sockaddr *)&remote_addr, sizeof(struct sockaddr));
  288.     led_blink(LED_TX_NET);
  289.     log_add_num_tx_udp_frame();
  290. }
  291.  
  292. /**
  293. * @brief 发送数据
  294. * @param data:发送数据存放地址
  295. * @param size:发送数据字节数
  296. * @param sockaddr: 目的地址
  297. */
  298.  
  299. void udp_socket_tx_sockaddr(uint8_t *data, uint16_t size, struct sockaddr_in sockaddr)
  300. {
  301.     if (!_is_net_work)
  302.     {
  303.         return;
  304.     }
  305. 	
  306. 	sendto(_socket, data, size, 0, (struct sockaddr *)&sockaddr, sizeof(struct sockaddr));
  307.     led_blink(LED_TX_NET);
  308.     log_add_num_tx_udp_frame();
  309. }
  310.  
  311. /**
  312. * @brief 发送数据给服务器
  313. * @param data:发送数据存放地址
  314. * @param size:发送数据字节数
  315. */
  316.  
  317. void udp_socket_tx_server(uint8_t *data, uint16_t size)
  318. {
  319.     if (!_is_net_work)
  320.     {
  321.         return;
  322.     }
  323. 	
  324. 	sendto(_socket, data, size, 0, (struct sockaddr *)&_server_addr, sizeof(struct sockaddr));
  325.     led_blink(LED_TX_NET);
  326.     log_add_num_tx_udp_frame();
  327. }
  328.  
  329. /**
  330. * @brief 发送数据给配置服务器
  331. * @note 配置服务器无效则发送给服务器
  332. * @param data:发送数据存放地址
  333. * @param size:发送数据字节数
  334. */
  335.  
  336. void udp_socket_tx_config_server(uint8_t *data, uint16_t size)
  337. {
  338.     if (!_is_net_work)
  339.     {
  340.         return;
  341.     }
  342. 	
  343.     bool is_valid = false;
  344.     T_Time time = get_local_time();
  345.     if (time.s - _last_config_frame_time.s < 2)
  346.     {
  347.         if (sub_time(get_local_time(), _last_config_frame_time) < CONFIG_TIMEOUT * 1000)
  348.         {
  349.             is_valid = true;
  350.         }
  351.     }
  352.     if (is_valid)
  353.     {
  354.         sendto(_socket, data, size, 0, (struct sockaddr *)&_config_server_addr, sizeof(struct sockaddr));
  355.     }
  356.     else
  357.     {
  358.         sendto(_socket, data, size, 0, (struct sockaddr *)&_server_addr, sizeof(struct sockaddr));
  359.     }
  360.     
  361.     led_blink(LED_TX_NET);
  362.     log_add_num_tx_udp_frame();
  363. }
  364.  
  365. /**
  366. * @brief 注册邮箱
  367. * @note 接收数据后会推送到此邮箱
  368. * @param mailbox: 邮箱地址
  369. */
  370.  
  371. void udp_socket_register_mailbox(rt_mailbox_t mailbox)
  372. {
  373.     _mailbox_array[_len_mailbox_array++] = mailbox;
  374. }
  375.  
  376. /**
  377. * @brief 增加传输层头后发送数据
  378. * @param dst_device: 目标设备类型
  379. * @param data: 发送数据存放地址
  380. * @param size: 发送数据字节数
  381. * @param sockaddr: 目的地址
  382. */
  383.  
  384. void udp_socket_tx_sockaddr_add_trans_head(uint8_t dst_device, uint8_t *data, uint16_t size, struct sockaddr_in sockaddr)
  385. {
  386.     if (size > PTH_MAX_BODY_LEN)
  387.     {
  388.         return;
  389.     }
  390.     
  391.     // 帧头
  392.     Buffer_Tx.buf[PTH_LEN_FRAME_HEAD_POS] = PTH_HEAD >> 8;
  393.     Buffer_Tx.buf[PTH_LEN_FRAME_HEAD_POS + 1] = PTH_HEAD & 0xff;
  394.     // 源设备类型
  395.     Buffer_Tx.buf[PTH_SRC_DEVICE_POS] = DEVICE_MY;
  396.     // 目的设备类型
  397.     Buffer_Tx.buf[PTH_DST_DEVICE_POS] = dst_device; 
  398.     // 附加信息
  399.     Buffer_Tx.buf[PTH_ADDITIONAL_POS] = 0; 
  400.     // 正文长度
  401.     Buffer_Tx.buf[PTH_BODY_LEN_POS] = size >> 8;
  402.     Buffer_Tx.buf[PTH_BODY_LEN_POS + 1] = size;
  403.     // 正文CRC
  404.     uint16_t crc_calc = crc_code(data, size);
  405.     Buffer_Tx.buf[PTH_BODY_CRC_POS] = crc_calc >> 8; 
  406.     Buffer_Tx.buf[PTH_BODY_CRC_POS + 1] = crc_calc; 
  407.     
  408.     // 正文
  409.     memcpy(Buffer_Tx.buf + PTH_LEN_FRAME_HEAD, data, size);
  410.     Buffer_Tx.len = size + PTH_LEN_FRAME_HEAD;
  411.     
  412. 	udp_socket_tx_sockaddr(Buffer_Tx.buf, Buffer_Tx.len, sockaddr);
  413. }
  414.  
  415. /**
  416. * @brief 发送确认帧
  417. * @param dst_device: 目标设备类型
  418. * @param cmd: 确认帧命令字
  419. * @param ack_cmd: 需要确认的命令
  420. * @param sockaddr: 目的地址
  421. */
  422.  
  423. void udp_socket_tx_sockaddr_ack_frame(uint8_t dst_device, uint8_t cmd, uint8_t ack_cmd, struct sockaddr_in sockaddr)
  424. {   
  425.     T_Buffer buffer;
  426.     buffer.len = 0;
  427.     
  428.     buffer.buf[buffer.len++] = cmd;
  429.     buffer.buf[buffer.len++] = ack_cmd;
  430.     
  431.     udp_socket_tx_sockaddr_add_trans_head(dst_device, buffer.buf, buffer.len, sockaddr);
  432. }
  433.  
  434. /**
  435. * @brief 增加传输层头后发送数据
  436. * @param dst_device: 目标设备类型
  437. * @param data: 发送数据存放地址
  438. * @param size: 发送数据字节数
  439. * @param sockaddr: 目的地址
  440. */
  441.  
  442. void udp_socket_tx_server_add_trans_head(uint8_t dst_device, uint8_t *data, uint16_t size)
  443. {
  444.     if (size > PTH_MAX_BODY_LEN)
  445.     {
  446.         return;
  447.     }
  448.     
  449.     // 帧头
  450.     Buffer_Tx.buf[PTH_LEN_FRAME_HEAD_POS] = PTH_HEAD >> 8;
  451.     Buffer_Tx.buf[PTH_LEN_FRAME_HEAD_POS + 1] = PTH_HEAD & 0xff;
  452.     // 源设备类型
  453.     Buffer_Tx.buf[PTH_SRC_DEVICE_POS] = DEVICE_MY;
  454.     // 目的设备类型
  455.     Buffer_Tx.buf[PTH_DST_DEVICE_POS] = dst_device; 
  456.     // 附加信息
  457.     Buffer_Tx.buf[PTH_ADDITIONAL_POS] = 0; 
  458.     // 正文长度
  459.     Buffer_Tx.buf[PTH_BODY_LEN_POS] = size >> 8;
  460.     Buffer_Tx.buf[PTH_BODY_LEN_POS + 1] = size;
  461.     // 正文CRC
  462.     uint16_t crc_calc = crc_code(data, size);
  463.     Buffer_Tx.buf[PTH_BODY_CRC_POS] = crc_calc >> 8; 
  464.     Buffer_Tx.buf[PTH_BODY_CRC_POS + 1] = crc_calc; 
  465.     
  466.     // 正文
  467.     memcpy(Buffer_Tx.buf + PTH_LEN_FRAME_HEAD, data, size);
  468.     Buffer_Tx.len = size + PTH_LEN_FRAME_HEAD;
  469.     
  470. 	udp_socket_tx_server(Buffer_Tx.buf, Buffer_Tx.len);
  471. }
  472.  
  473. /**
  474. * @brief 发送确认帧
  475. * @param dst_device: 目标设备类型
  476. * @param cmd: 确认帧命令字
  477. * @param ack_cmd: 需要确认的命令
  478. * @param sockaddr: 目的地址
  479. */
  480.  
  481. void udp_socket_tx_server_ack_frame(uint8_t dst_device, uint8_t cmd, uint8_t ack_cmd)
  482. {   
  483.     T_Buffer buffer;
  484.     buffer.len = 0;
  485.     
  486.     buffer.buf[buffer.len++] = cmd;
  487.     buffer.buf[buffer.len++] = ack_cmd;
  488.     
  489.     udp_socket_tx_server(Buffer_Tx.buf, Buffer_Tx.len);
  490. }
接收的应用模块示例： 
  1. /**
  2. * Copyright (c), 2015-2025
  3. * @file remote_reset.c
  4. * @brief 远程复位功能模块主文件
  5. * @author jdh
  6. * @verbatim 
  7. * Change Logs:
  8. * Date           Author       Notes
  9. * 2018-01-08     jdh          新建
  10. * @endverbatim 
  11. */
  12.  
  13. #include "remote_reset.h"
  14. #include "protocol.h"
  15.  
  16. #define TAG             "LOG:REMOTE_RESET"
  17.  
  18. /**
  19. * @brief 日志项编号
  20. */
  21.  
  22. static uint8_t _log_item = 0;
  23.  
  24. static void thread_udp_rx(void* parameter);
  25.  
  26. /**
  27. * @brief 模块载入
  28. */
  29.  
  30. void remote_reset_load(void)
  31. {                              
  32.     _log_item = log_register(TAG);
  33.     
  34.     rt_thread_t tid_udp_rx = rt_thread_create("rr_udp_rx",
  35. 										thread_udp_rx, (void*)0,
  36. 										THREAD_STACK_BIG, THREAD_PRIORITY_NORMAL, THREAD_SLICE_NORMAL);
  37. 	rt_thread_startup(tid_udp_rx);
  38. }
  39.  
  40. static void thread_udp_rx(void* parameter)
  41. {   
  42. 	rt_mailbox_t mb = rt_mb_create("mb_udp_rx", 32, RT_IPC_FLAG_FIFO);
  43.     udp_socket_register_mailbox(mb);
  44.     
  45.     struct UdpSocketRx *udp_socket_rx;
  46.     while (1)
  47.     {
  48.         if (rt_mb_recv(mb, (rt_uint32_t *)&udp_socket_rx, RT_WAITING_FOREVER) == RT_EOK)
  49.         {
  50.             if (udp_socket_rx->buffer.buf[PTH_SRC_DEVICE_POS] == DEVICE_SERVER)
  51.             {
  52.                 uint8_t cmd = udp_socket_rx->buffer.buf[PTH_LEN_FRAME_HEAD];
  53.                 switch (cmd)
  54.                 {
  55.                     case PSRAS_RESET:
  56.                     {
  57.                         log_w(_log_item, "udp rx remote reset cmd\n");
  58.                         // 应答
  59.                         udp_socket_tx_sockaddr_ack_frame(DEVICE_SERVER, PSRAS_ACK, PSRAS_RESET, udp_socket_rx->sockaddr);
  60.                         // 复位生效
  61.                         reset_manage_delay_reset();
  62.                         break;
  63.                     }
  64.                 }
  65.             }
  66.         }
  67.     }
  68. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/67531
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号