21ic电子技术开发论坛»论坛首页 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 【AT-START-F407测评】+udp通讯测试
返回列表 发新帖

[AT32F407] 【AT-START-F407测评】+udp通讯测试

[复制链接]
 楼主| yinwuqing110 发表于 2023-1-8 20:46 | 显示全部楼层 |阅读模式
freeRTOS, lwIP, udp
        AT-START-F407板载以太网PHY带RJ45连接器，以太网PHY联杰DM9162NP支持10/100Mbps双速以太网通讯，使用以太网MAC时，JP8连体跳线须选择右测IO端。本次工程是在参考官方提供的FreeRTOS例程上，移植进lwip源码，实现PC端与AT-START-F407建立UDP网络通讯。本来想通过0.96寸OLED屏显示PC端发送过来的数据，但不知道是OLED屏硬件的问题还是AT-START-F407板子设置的问题，硬是没能成功驱动。论坛上有坛友使用AT-START-F407成功驱动OLED屏的，奇怪的是采用仿STM32的代码驱动，初始化GPIO函数中还带有“GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_10MHz;”，雅特力官方的外设库中并没有所谓的“GPIO_MaxSpeed ”成员参数，也不知道坛友们是如何封装并顺利驱动的。
        移植lwip，首先得进入lwip官网，下载最新的“lwIP 2.1.3 released”版本，网址：https://savannah.nongnu.org/projects/lwip/
        然后参考“at32f403a_407_freertos_demo”工程，将lwip源码加入到工程中，并添加头文件路径。官方提供的“at32f407_emac_iap_demo”可借鉴一下，主要用到开发板上的emac模块驱动，DM9162NP相关PHY底层库函数。
        在主函数中创建四个进程任务，任务优先级都设置成2，多任务并发执行，任务四中的udp接收线程优先级设置成1。部分参考代码如下：
复制
  1. #include "at32f403a_407_board.h"
    

  2. #include "at32f403a_407_clock.h"
    

  3. #include "at32_emac.h"
    

  4. #include "stdio.h"
    

  5. #include "FreeRTOS.h"
    

  6. #include "task.h"
    


  7. 

  8. extern void tcpip_stack_init(void);
    

  9. extern void udpecho_init(void);
    


  10. 

  11. TaskHandle_t led2_handler;
    

  12. TaskHandle_t led3_handler;
    

  13. TaskHandle_t led4_handler;
    

  14. TaskHandle_t network_handler;
    


  15. 

  16. /* led2 task */
    

  17. void led2_task_function(void *pvParameters);
    

  18. /* led3 task */
    

  19. void led3_task_function(void *pvParameters);
    

  20. /* led4 task */
    

  21. void led4_task_function(void *pvParameters);
    

  22. /* AppTaskCreate task */
    

  23. void AppTaskCreate(void *pvParameters);
    


  24. 

  25. int main(void)
    

  26. {
    

  27.   nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
    

  28.   system_clock_config();
    

  29.   
    

  30.   /* init led2*/
    

  31.   at32_led_init(LED2);
    

  32.   /* init led3*/
    

  33.   at32_led_init(LED3);
    

  34.   /* init led4*/
    

  35.   at32_led_init(LED4);
    

  36.   
    

  37.   /* init usart1 */
    

  38.   uart_print_init(115200);
    

  39.   
    

  40.   /* enter critical */
    

  41.   taskENTER_CRITICAL(); 
    


  42. 

  43.   /* create led2 task */
    

  44.   if(xTaskCreate((TaskFunction_t )led2_task_function,     
    

  45.                  (const char*    )"LED2_task",   
    

  46.                  (uint16_t       )512, 
    

  47.                  (void*          )NULL,
    

  48.                  (UBaseType_t    )2,
    

  49.                  (TaskHandle_t*  )&led2_handler) != pdPASS)
    

  50.   {
    

  51.     printf("LED2 task could not be created as there was insufficient heap memory remaining.\r\n");
    

  52.   }        
    

  53.   else
    

  54.   {
    

  55.     printf("LED2 task was created successfully.\r\n");
    

  56.   }
    

  57.           /* create led3 task */
    

  58.   if(xTaskCreate((TaskFunction_t )led3_task_function,     
    

  59.                  (const char*    )"LED3_task",   
    

  60.                  (uint16_t       )512, 
    

  61.                  (void*          )NULL,
    

  62.                  (UBaseType_t    )2,
    

  63.                  (TaskHandle_t*  )&led2_handler) != pdPASS)
    

  64.   {
    

  65.     printf("LED3 task could not be created as there was insufficient heap memory remaining.\r\n");
    

  66.   }        
    

  67.   else
    

  68.   {
    

  69.     printf("LED3 task was created successfully.\r\n");
    

  70.   }
    

  71.           /* create led4 task */
    

  72.   if(xTaskCreate((TaskFunction_t )led4_task_function,     
    

  73.                  (const char*    )"LED4_task",   
    

  74.                  (uint16_t       )512, 
    

  75.                  (void*          )NULL,
    

  76.                  (UBaseType_t    )2,
    

  77.                  (TaskHandle_t*  )&led4_handler) != pdPASS)
    

  78.   {
    

  79.     printf("LED4 task could not be created as there was insufficient heap memory remaining.\r\n");
    

  80.   }        
    

  81.   else
    

  82.   {
    

  83.     printf("LED4 task was created successfully.\r\n");
    

  84.   }
    

  85.   if(xTaskCreate((TaskFunction_t )AppTaskCreate,     
    

  86.                  (const char*    )"AppTaskCreate_task",   
    

  87.                  (uint16_t       )512, 
    

  88.                  (void*          )NULL,
    

  89.                  (UBaseType_t    )2,
    

  90.                  (TaskHandle_t*  )&network_handler) != pdPASS)
    

  91.   {
    

  92.     printf("AppTaskCreate task could not be created.\r\n");
    

  93.   }        
    

  94.   else
    

  95.   {
    

  96.     printf("AppTaskCreate task was created successfully.\r\n");
    

  97.   }
    

  98.   
    

  99.   /* exit critical */            
    

  100.   taskEXIT_CRITICAL();      
    

  101.               
    

  102.   /* start scheduler */            
    

  103.   vTaskStartScheduler(); 
    

  104.   
    

  105. }
    


  106. 

  107. /* led2 task function */
    

  108. void led2_task_function(void *pvParameters)
    

  109. {
    

  110.   while(1)
    

  111.   {
    

  112.     at32_led_toggle(LED2);
    

  113.     vTaskDelay(500);
    

  114.   }
    

  115. }
    


  116. 

  117. /* led3 task function */
    

  118. void led3_task_function(void *pvParameters)
    

  119. {
    

  120.   while(1)
    

  121.   {
    

  122.     at32_led_toggle(LED3);
    

  123.     vTaskDelay(500);
    

  124.   }
    

  125. }
    

  126. /* led4 task function */
    

  127. void led4_task_function(void *pvParameters)
    

  128. {
    

  129.   while(1)
    

  130.   {
    

  131.     at32_led_toggle(LED4);
    

  132.     vTaskDelay(500);
    

  133.   }
    

  134. }
    

  135. /* AppTaskCreate_task */
    

  136. void AppTaskCreate(void *pvParameters)
    

  137. {
    

  138.   while(emac_system_init() == ERROR);
    

  139.   tcpip_stack_init();
    

  140.   udpecho_init();
    

  141.   while(1)
    

  142.   {
    

  143.     vTaskDelay(500);
    

  144.   }
    

  145. }
   netconf.c中设置本地ip，这里使用静态分配ip地址，没有使能DHCP功能。
复制
  1. #include "lwip/memp.h"
    

  2. #include "lwip/tcp.h"
    

  3. #include "lwip/priv/tcp_priv.h"
    

  4. #include "lwip/udp.h"
    

  5. #include "netif/etharp.h"
    

  6. #include "lwip/dhcp.h"
    

  7. #include "ethernetif.h"
    

  8. #include "netconf.h"
    

  9. #include "stdio.h"
    

  10. #include "at32_emac.h"
    


  11. 

  12. #define MAC_ADDR_LENGTH                  (6)
    

  13. #define ADDR_LENGTH                      (4)
    


  14. 

  15. struct netif netif;
    

  16. TaskHandle_t link_status_handler;
    

  17. volatile uint32_t tcp_timer = 0;
    

  18. volatile uint32_t arp_timer = 0;
    


  19. 

  20. static uint8_t mac_address[MAC_ADDR_LENGTH] = {0, 0, 0x44, 0x45, 0x56, 1};
    

  21. #if LWIP_DHCP
    

  22. volatile uint32_t dhcp_fine_timer = 0;
    

  23. volatile uint32_t dhcp_coarse_timer = 0;
    

  24. #else
    

  25. static uint8_t local_ip[ADDR_LENGTH]   = {192, 168, 0, 105};
    

  26. static uint8_t local_gw[ADDR_LENGTH]   = {192, 168, 0, 1};
    

  27. static uint8_t local_mask[ADDR_LENGTH] = {255, 255, 255, 0};
    

  28. #endif
    


  29. 

  30. void tcpip_stack_init(void)
    

  31. {
    

  32.   ip_addr_t ipaddr;
    

  33.   ip_addr_t netmask;
    

  34.   ip_addr_t gw;
    

  35.   
    

  36.   /* Initializes the dynamic memory heap defined by MEM_SIZE.*/
    

  37.   mem_init();
    


  38. 

  39.   /* Initializes the memory pools defined by MEMP_NUM_x.*/
    

  40.   memp_init();
    


  41. 


  42. 

  43. #if LWIP_DHCP  //need DHCP server
    

  44.   ipaddr.addr = 0;
    

  45.   netmask.addr = 0;
    

  46.   gw.addr = 0;
    


  47. 

  48. #else
    

  49.   IP4_ADDR(&ipaddr, local_ip[0], local_ip[1], local_ip[2], local_ip[3]);
    

  50.   IP4_ADDR(&netmask, local_mask[0], local_mask[1], local_mask[2], local_mask[3]);
    

  51.   IP4_ADDR(&gw, local_gw[0], local_gw[1], local_gw[2], local_gw[3]);
    

  52.         printf("\r\n");
    

  53.         printf("local_ip:%d.%d.%d.%d\r\n",local_ip[0], local_ip[1], local_ip[2], local_ip[3]);
    

  54.         printf("local_mask:%d.%d.%d.%d\r\n",local_mask[0], local_mask[1], local_mask[2], local_mask[3]);
    

  55.         printf("local_gw:%d.%d.%d.%d\r\n",local_gw[0], local_gw[1], local_gw[2], local_gw[3]);
    

  56. #endif
    


  57. 

  58.   lwip_set_mac_address(mac_address);
    

  59. if(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, ðernetif_init, &netif_input) == NULL)
    

  60.   {
    

  61.     while(1);
    

  62.   }
    

  63.   
    

  64.   /*  Registers the default network interface.*/
    

  65.   netif_set_default(&netif);
    


  66. 

  67. #if LWIP_DHCP
    

  68. dhcp_start(&netif);
    

  69. #endif
    

  70. /*  When the netif is fully configured this function must be called.*/
    

  71.   netif_set_up(&netif);  
    

  72.   
    

  73.   /* Set the link callback function, this function is called on change of link status*/
    

  74.   netif_set_link_callback(&netif, ethernetif_update_config);
    

  75.   
    

  76.   /* Create the Ethernet link handler thread */
    

  77.   xTaskCreate((TaskFunction_t)ethernetif_set_link, "ethernetif_set_link", 512, &netif, tskIDLE_PRIORITY + 3, &link_status_handler);
    

  78. }
    


  79. 

  80. void lwip_pkt_handle(void)
    

  81. {
    

  82.   /* Read a received packet from the Ethernet buffers and send it to the lwIP for handling */
    

  83.   if(ethernetif_input(&netif) != ERR_OK)
    

  84.   {
    

  85.     while(1);
    

  86.   }
    

  87. }
    


  88. 

  89. void lwip_periodic_handle(volatile uint32_t localtime)
    

  90. {
    

  91.   /* TCP periodic process every 250 ms */
    

  92.   if (localtime - tcp_timer >= TCP_TMR_INTERVAL)
    

  93.   {
    

  94.     tcp_timer =  localtime;
    

  95.     tcp_tmr();
    

  96.   }
    

  97.   /* ARP periodic process every 5s */
    

  98.   if (localtime - arp_timer >= ARP_TMR_INTERVAL)
    

  99.   {
    

  100.     arp_timer =  localtime;
    

  101.     etharp_tmr();
    

  102.   }
    


  103. 

  104. #if LWIP_DHCP
    

  105.   /* Fine DHCP periodic process every 500ms */
    

  106.   if (localtime - dhcp_fine_timer >= DHCP_FINE_TIMER_MSECS)
    

  107.   {
    

  108.     dhcp_fine_timer =  localtime;
    

  109.     dhcp_fine_tmr();
    

  110.   }
    

  111.   /* DHCP Coarse periodic process every 60s */
    

  112.   if (localtime - dhcp_coarse_timer >= DHCP_COARSE_TIMER_MSECS)
    

  113.   {
    

  114.     dhcp_coarse_timer =  localtime;
    

  115.     dhcp_coarse_tmr();
    

  116.   }
    

  117. #endif
    

  118. }
复制
  1. #include "lwip/opt.h"
    


  2. 

  3. #if LWIP_NETCONN
    

  4. #include "lwip/api.h"
    

  5. #include "lwip/sys.h"
    


  6. 

  7. #define UDPECHO_THREAD_PRIO          1
    

  8. #define UDPECHO_STK_SIZE                         256  
    

  9. TaskHandle_t Udpecho_Handler;
    


  10. 

  11. static struct netconn *conn;
    

  12. static struct netbuf *buf;
    

  13. static ip_addr_t *addr;
    

  14. static unsigned short port;
    

  15. static void udpecho_thread(void *arg)
    

  16. {
    

  17.   err_t err, recv_err;
    


  18. 

  19.   LWIP_UNUSED_ARG(arg);
    


  20. 

  21.   conn = netconn_new(NETCONN_UDP);
    

  22.         printf("connection create successfully\n");
    

  23.   if (conn!= NULL)
    

  24.   {
    

  25.     err = netconn_bind(conn, IP_ADDR_ANY, 8080);
    

  26.                 printf("bind successfully\n");
    

  27.     if (err == ERR_OK)
    

  28.     {
    

  29.       while (1)
    

  30.       {
    

  31.                                 printf("Receiving...\n");
    

  32.         recv_err = netconn_recv(conn, &buf);
    

  33.                                 printf("Received done\n");
    


  34. 

  35.         if (recv_err == ERR_OK)
    

  36.         {
    

  37.           addr = netbuf_fromaddr(buf);
    

  38.           port = netbuf_fromport(buf);
    

  39.           netconn_connect(conn, addr, port);
    

  40.           buf->addr.addr = 0;
    

  41.           netconn_send(conn,buf);
    

  42.           netbuf_delete(buf);
    

  43.         }
    

  44.       }
    

  45.     }
    

  46.     else
    

  47.     {
    

  48.       netconn_delete(conn);
    

  49.     }
    

  50.   }
    

  51. }
    

  52. void udpecho_init(void)
    

  53. {
    

  54.   sys_thread_new("udpecho_thread", udpecho_thread, NULL, UDPECHO_STK_SIZE,UDPECHO_THREAD_PRIO );        
    

  55. }
    

  56. #endif /* LWIP_NETCONN */
     编译、下载到开发板中，PC端打开串口调试助手，根据串口输出信息，先在“cmd窗口”中ping一下，看是否能够正常ping通。
打印信息.png
ping信息.png
      然后在PC端中打开“netassist”网路调试助手，并设置好udp通讯方式，本地主机地址（PC）的ip地址，端口号设置成代码中设定的8080；根据串口打印信息，设置远程主机（AT-START-F407）的ip地址，端口号同样设置成8080。
netassist.zip (548.52 KB, 下载次数: 4)
网络通讯.gif
        开发板上的各个指示灯显示如下：
现象.gif
         一路走来，感觉移植lwip还是需要点耐心的，结合FreeRTOS，需要打开的宏必须得打开，否则会报莫名其妙的error，这里尤其注意在“FreeRTOS.h”的文件中，打开“configUSE_COUNTING_SEMAPHORES”宏。以下附件为工程文件，此次分享就告一段落，咱们后会有期。
FreeRTOS_lwip_project.zip (4.81 MB, 下载次数: 12)
回复 赏

举报

相关帖子
updownq 发表于 2023-1-9 10:42 | 显示全部楼层
这个udp的速度怎么样              
回复 赏

举报

 楼主| yinwuqing110 发表于 2023-1-9 13:42 | 显示全部楼层
updownq 发表于 2023-1-9 10:42
这个udp的速度怎么样

挺快的呀，具体数值就没测了
回复 赏

举报

claretttt 发表于 2023-1-9 14:43 | 显示全部楼层
使用的是哪个网络模块？              
回复 赏

举报

 楼主| yinwuqing110 发表于 2023-1-10 09:29 | 显示全部楼层
claretttt 发表于 2023-1-9 14:43
使用的是哪个网络模块？

开发板上就有集成的DM9162NP芯片呀
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

yinwuqing110

106

主题

1096

帖子

7

粉丝
快速回复 返回顶部 返回列表