【NUCLEO-H563ZI测评】5.NetXDuo UDP服务器

                        【NUCLEO-H563ZI测评】5.NetXDuo UDP服务器


玩了一下THREADX后，发现NetXDuo这个东西蛮好的，那不也得玩一下啊。

下载解压en.stm32cubeh5-v1-1-0。
mdk打开STM32Cube_FW_H5_V1.1.0\Projects\NUCLEO-H563ZI\Applications\NetXDuo\Nx_UDP_Echo_Server\MDK-ARM目录里的Nx_UDP_Echo_Server。


编译下载运行
连接串口和以太网口 串口显示如下


找一个udp的调试软件并创建一个客户端连接这个板子的服务器，发送数据，那边就收到了


主要代码在app_netxduo.c中
MX_NetXDuo_Init(VOID *memory_ptr)中创建各种任务

1. UINT MX_NetXDuo_Init(VOID *memory_ptr)
   
2. {
   
3.   UINT ret = NX_SUCCESS;
   
4.   TX_BYTE_POOL *byte_pool = (TX_BYTE_POOL*)memory_ptr;
   
5.    /* USER CODE BEGIN App_NetXDuo_MEM_POOL */
   
6.   /* USER CODE END App_NetXDuo_MEM_POOL */
   
7.   /* USER CODE BEGIN 0 */
   
8.   printf("Nx_UDP_Echo_Server application started..\n");
   
9.   /* USER CODE END 0 */
   
10.   /* Initialize the NetXDuo system. */
    
11.   CHAR *pointer;
    
12.   nx_system_initialize();
    
13.     /* Allocate the memory for packet_pool.  */
    
14.   if (tx_byte_allocate(byte_pool, (VOID **) &pointer, NX_APP_PACKET_POOL_SIZE, TX_NO_WAIT) != TX_SUCCESS)
    
15.   {
    
16.     return TX_POOL_ERROR;
    
17.   }
    
18.   /* Create the Packet pool to be used for packet allocation,
    
19.    * If extra NX_PACKET are to be used the NX_APP_PACKET_POOL_SIZE should be increased
    
20.    */
    
21.   ret = nx_packet_pool_create(&NxAppPool, "NetXDuo App Pool", DEFAULT_PAYLOAD_SIZE, pointer, NX_APP_PACKET_POOL_SIZE);
    
22.   if (ret != NX_SUCCESS)
    
23.   {
    
24.     return NX_POOL_ERROR;
    
25.   }
    
26.     /* Allocate the memory for Ip_Instance */
    
27.   if (tx_byte_allocate(byte_pool, (VOID **) &pointer, Nx_IP_INSTANCE_THREAD_SIZE, TX_NO_WAIT) != TX_SUCCESS)
    
28.   {
    
29.     return TX_POOL_ERROR;
    
30.   }
    
31.    /* Create the main NX_IP instance */
    
32.   ret = nx_ip_create(&NetXDuoEthIpInstance, "NetX Ip instance", NX_APP_DEFAULT_IP_ADDRESS, NX_APP_DEFAULT_NET_MASK, &NxAppPool, nx_stm32_eth_driver,
    
33.                      pointer, Nx_IP_INSTANCE_THREAD_SIZE, NX_APP_INSTANCE_PRIORITY);
    
34.   if (ret != NX_SUCCESS)
    
35.   {
    
36.     return NX_NOT_SUCCESSFUL;
    
37.   }
    
38.     /* Allocate the memory for ARP */
    
39.   if (tx_byte_allocate(byte_pool, (VOID **) &pointer, DEFAULT_ARP_CACHE_SIZE, TX_NO_WAIT) != TX_SUCCESS)
    
40.   {
    
41.     return TX_POOL_ERROR;
    
42.   }
    
43.   /* Enable the ARP protocol and provide the ARP cache size for the IP instance */
    
44.   /* USER CODE BEGIN ARP_Protocol_Initialization */
    
45.   /* USER CODE END ARP_Protocol_Initialization */
    
46.   ret = nx_arp_enable(&NetXDuoEthIpInstance, (VOID *)pointer, DEFAULT_ARP_CACHE_SIZE);
    
47.   if (ret != NX_SUCCESS)
    
48.   {
    
49.     return NX_NOT_SUCCESSFUL;
    
50.   }
    
51.   /* Enable the ICMP */
    
52.   /* USER CODE BEGIN ICMP_Protocol_Initialization */
    
53.   /* USER CODE END ICMP_Protocol_Initialization */
    
54.   ret = nx_icmp_enable(&NetXDuoEthIpInstance);
    
55.   if (ret != NX_SUCCESS)
    
56.   {
    
57.     return NX_NOT_SUCCESSFUL;
    
58.   }
    
59.   /* Enable TCP Protocol */
    
60.   /* USER CODE BEGIN TCP_Protocol_Initialization */
    
61.   /* USER CODE END TCP_Protocol_Initialization */
    
62.   ret = nx_tcp_enable(&NetXDuoEthIpInstance);
    
63.   if (ret != NX_SUCCESS)
    
64.   {
    
65.     return NX_NOT_SUCCESSFUL;
    
66.   }
    
67.   /* Enable the UDP protocol required for  DHCP communication */
    
68.   /* USER CODE BEGIN UDP_Protocol_Initialization */
    
69.   /* USER CODE END UDP_Protocol_Initialization */
    
70.   ret = nx_udp_enable(&NetXDuoEthIpInstance);
    
71.   if (ret != NX_SUCCESS)
    
72.   {
    
73.     return NX_NOT_SUCCESSFUL;
    
74.   }
    
75.    /* Allocate the memory for main thread   */
    
76.   if (tx_byte_allocate(byte_pool, (VOID **) &pointer, NX_APP_THREAD_STACK_SIZE, TX_NO_WAIT) != TX_SUCCESS)
    
77.   {
    
78.     return TX_POOL_ERROR;
    
79.   }
    
80.   /* Create the main thread */
    
81.   ret = tx_thread_create(&NxAppThread, "NetXDuo App thread", App_Main_Thread_Entry , 0, pointer, NX_APP_THREAD_STACK_SIZE,
    
82.                          NX_APP_THREAD_PRIORITY, NX_APP_THREAD_PRIORITY, TX_NO_TIME_SLICE, TX_AUTO_START);
    
83.   if (ret != TX_SUCCESS)
    
84.   {
    
85.     return TX_THREAD_ERROR;
    
86.   }
    
87.   /* Create the DHCP client */
    
88.   /* USER CODE BEGIN DHCP_Protocol_Initialization */
    
89.   /* USER CODE END DHCP_Protocol_Initialization */
    
90.   ret = nx_dhcp_create(&DHCPClient, &NetXDuoEthIpInstance, "DHCP Client");
    
91.   if (ret != NX_SUCCESS)
    
92.   {
    
93.     return NX_DHCP_ERROR;
    
94.   }
    
95.   /* set DHCP notification callback  */
    
96.   tx_semaphore_create(&DHCPSemaphore, "DHCP Semaphore", 0);
    
97.   /* USER CODE BEGIN MX_NetXDuo_Init */
    
98.   /* Allocate the app UDP thread entry pool. */
    
99.   ret = tx_byte_allocate(byte_pool, (VOID **) &pointer, 2 * DEFAULT_MEMORY_SIZE, TX_NO_WAIT);
    
100.   if (ret != TX_SUCCESS)
     
101.   {
     
102.     return TX_POOL_ERROR;
     
103.   }
     
104.   /* create the UDP server thread */
     
105.   ret = tx_thread_create(&AppUDPThread, "App UDP Thread", App_UDP_Thread_Entry, 0, pointer, 2 * DEFAULT_MEMORY_SIZE,
     
106.                         DEFAULT_PRIORITY, DEFAULT_PRIORITY, TX_NO_TIME_SLICE, TX_DONT_START);
     
107.   if (ret != TX_SUCCESS)
     
108.   {
     
109.     return TX_THREAD_ERROR;
     
110.   }
     
111.   /* Allocate the memory for Link thread   */
     
112.   if (tx_byte_allocate(byte_pool, (VOID **) &pointer,2 *  DEFAULT_MEMORY_SIZE, TX_NO_WAIT) != TX_SUCCESS)
     
113.   {
     
114.     return TX_POOL_ERROR;
     
115.   }
     
116.   /* create the Link thread */
     
117.   ret = tx_thread_create(&AppLinkThread, "App Link Thread", App_Link_Thread_Entry, 0, pointer, 2 * DEFAULT_MEMORY_SIZE,
     
118.                          LINK_PRIORITY, LINK_PRIORITY, TX_NO_TIME_SLICE, TX_AUTO_START);
     
119.   if (ret != TX_SUCCESS)
     
120.   {
     
121.     return TX_THREAD_ERROR;
     
122.   }
     
123.   /* USER CODE END MX_NetXDuo_Init */
     
124.   return ret;
     
125. }

复制代码

相应的入口函数中处理

1. 
   
2. static VOID ip_address_change_notify_callback(NX_IP *ip_instance, VOID *ptr)
   
3. {
   
4.   /* USER CODE BEGIN ip_address_change_notify_callback */
   
5.   /* USER CODE END ip_address_change_notify_callback */
   
6.   /* release the semaphore as soon as an IP address is available */
   
7.   tx_semaphore_put(&DHCPSemaphore);
   
8. }
   
9. /**
   
10. * [url=home.php?mod=space&uid=247401]@brief[/url]  Main thread entry.
    
11. * @param thread_input: ULONG user argument used by the thread entry
    
12. * @retval none
    
13. */
    
14. static VOID App_Main_Thread_Entry (ULONG thread_input)
    
15. {
    
16.   /* USER CODE BEGIN Nx_App_Thread_Entry 0 */
    
17.   /* USER CODE END Nx_App_Thread_Entry 0 */
    
18.   UINT ret = NX_SUCCESS;
    
19.   /* USER CODE BEGIN Nx_App_Thread_Entry 1 */
    
20.   /* USER CODE END Nx_App_Thread_Entry 1 */
    
21.   /* register the IP address change callback */
    
22.   ret = nx_ip_address_change_notify(&NetXDuoEthIpInstance, ip_address_change_notify_callback, NULL);
    
23.   if (ret != NX_SUCCESS)
    
24.   {
    
25.     /* USER CODE BEGIN IP address change callback error */
    
26.     Error_Handler();
    
27.     /* USER CODE END IP address change callback error */
    
28.   }
    
29.   /* start the DHCP client */
    
30.   ret = nx_dhcp_start(&DHCPClient);
    
31.   if (ret != NX_SUCCESS)
    
32.   {
    
33.     /* USER CODE BEGIN DHCP client start error */
    
34.     Error_Handler();
    
35.     /* USER CODE END DHCP client start error */
    
36.   }
    
37.   /* wait until an IP address is ready */
    
38.   if(tx_semaphore_get(&DHCPSemaphore, NX_APP_DEFAULT_TIMEOUT) != TX_SUCCESS)
    
39.   {
    
40.     /* USER CODE BEGIN DHCPSemaphore get error */
    
41.     Error_Handler();
    
42.     /* USER CODE END DHCPSemaphore get error */
    
43.   }
    
44.   /* USER CODE BEGIN Nx_App_Thread_Entry 2 */
    
45.   /* get IP address */
    
46.   ret = nx_ip_address_get(&NetXDuoEthIpInstance, &IpAddress, &NetMask);
    
47.   /* print the IP address */
    
48.   PRINT_IP_ADDRESS(IpAddress);
    
49.   if (ret != TX_SUCCESS)
    
50.   {
    
51.     Error_Handler();
    
52.   }
    
53.   /* Now the network is correctly initialized, start the UDP server thread */
    
54.   tx_thread_resume(&AppUDPThread);
    
55.   /* this thread is not needed any more, we relinquish it */
    
56.   tx_thread_relinquish();
    
57.   /* USER CODE END Nx_App_Thread_Entry 2 */
    
58. }
    
59. /* USER CODE BEGIN 1 */
    
60. static VOID App_UDP_Thread_Entry(ULONG thread_input)
    
61. {
    
62.   UINT ret;
    
63.   ULONG bytes_read;
    
64.   UINT source_port;
    
65.   UCHAR data_buffer[512];
    
66.   ULONG source_ip_address;
    
67.   NX_PACKET *data_packet;
    
68.   /* create the UDP socket */
    
69.   ret = nx_udp_socket_create(&NetXDuoEthIpInstance, &UDPSocket, "UDP Server Socket", NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, QUEUE_MAX_SIZE);
    
70.   if (ret != NX_SUCCESS)
    
71.   {
    
72.      Error_Handler();
    
73.   }
    
74.   /* bind the socket indefinitely on the required port */
    
75.   ret = nx_udp_socket_bind(&UDPSocket, DEFAULT_PORT, TX_WAIT_FOREVER);
    
76.   if (ret != NX_SUCCESS)
    
77.   {
    
78.      Error_Handler();
    
79.   }
    
80.   else
    
81.   {
    
82.     printf("UDP Server listening on PORT %d.. \n", DEFAULT_PORT);
    
83.   }
    
84.   while(1)
    
85.   {
    
86.     TX_MEMSET(data_buffer, '\0', sizeof(data_buffer));
    
87.     /* wait for data for 1 sec */
    
88.     ret = nx_udp_socket_receive(&UDPSocket, &data_packet, 100);
    
89.     if (ret == NX_SUCCESS)
    
90.     {
    
91.       /* data is available, read it into the data buffer */
    
92.       nx_packet_data_retrieve(data_packet, data_buffer, &bytes_read);
    
93.       /* get info about the client address and port */
    
94.       nx_udp_source_extract(data_packet, &source_ip_address, &source_port);
    
95.       /* print the client address, the remote port and the received data */
    
96.       PRINT_DATA(source_ip_address, source_port, data_buffer);
    
97.       /* resend the same packet to the client */
    
98.       ret =  nx_udp_socket_send(&UDPSocket, data_packet, source_ip_address, source_port);
    
99.       /* toggle the green led to monitor visually the traffic */
    
100.       HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_0);
     
101.     }
     
102.     else
     
103.     {
     
104.         /* the server is in idle state, toggle the green led */
     
105.         HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_0);
     
106.     }
     
107.   }
     
108. }
     
109. /**
     
110. * [url=home.php?mod=space&uid=247401]@brief[/url]  Link thread entry
     
111. * @param thread_input: ULONG thread parameter
     
112. * @retval none
     
113. */
     
114. static VOID App_Link_Thread_Entry(ULONG thread_input)
     
115. {
     
116.   ULONG actual_status;
     
117.   UINT linkdown = 0, status;
     
118.   while(1)
     
119.   {
     
120.     /* Get Physical Link status. */
     
121.     status = nx_ip_interface_status_check(&NetXDuoEthIpInstance, 0, NX_IP_LINK_ENABLED,
     
122.                                       &actual_status, 10);
     
123.     if(status == NX_SUCCESS)
     
124.     {
     
125.       if(linkdown == 1)
     
126.       {
     
127.         linkdown = 0;
     
128.         status = nx_ip_interface_status_check(&NetXDuoEthIpInstance, 0, NX_IP_ADDRESS_RESOLVED,
     
129.                                       &actual_status, 10);
     
130.         if(status == NX_SUCCESS)
     
131.         {
     
132.           /* The network cable is connected again. */
     
133.           printf("The network cable is connected again.\n");
     
134.           /* Print UDP Echo Server is available again. */
     
135.           printf("UDP Echo Server is available again.\n");
     
136.         }
     
137.         else
     
138.         {
     
139.           /* The network cable is connected. */
     
140.           printf("The network cable is connected.\n");
     
141.           /* Send command to Enable Nx driver. */
     
142.           nx_ip_driver_direct_command(&NetXDuoEthIpInstance, NX_LINK_ENABLE,
     
143.                                       &actual_status);
     
144.           /* Restart DHCP Client. */
     
145.           nx_dhcp_stop(&DHCPClient);
     
146.           nx_dhcp_start(&DHCPClient);
     
147.         }
     
148.       }
     
149.     }
     
150.     else
     
151.     {
     
152.       if(0 == linkdown)
     
153.       {
     
154.         linkdown = 1;
     
155.         /* The network cable is not connected. */
     
156.         printf("The network cable is not connected.\n");
     
157.       }
     
158.     }
     
159.     tx_thread_sleep(NX_ETH_CABLE_CONNECTION_CHECK_PERIOD);
     
160.   }
     
161. }
     
162. /* USER CODE END 1 */

复制代码

  

我也想玩，最近玩网络玩的很嗨，我觉得很有意思

UDP确实简单了一些，其实玩一些复杂的协议也是可以的了

这个和普通的lwip来说，有啥优势不？