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

RT-Thread Studio配置LAN8720+LWIP+TCP服务器实现_lan8720a rtthread

作者：小小林熬夜学编程 | 2024-03-06 17:57:28

赞

踩

lan8720a rtthread

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

由于项目上需要使用RT-Thread建立TCP服务器实现与客户端的数据交互，查阅了不少资料以及踩了不少坑，这里记录和分享一下实现的过程，希望能帮助到有需要的同学，您的支持是我创作的最大动力，谢谢！

提示：以下是本篇文章正文内容

一、RT-Thread配置lan8720+lwip+tcp服务器步骤

1.打开RT-Thread Studio 新建好工程并（关于怎么新建工程请自行查看rtt官方提供的帮助文档）在board.h文件中开启ETH相关的宏

                       

2.新增一个头文件lan8720.c和lan8720.h文件用于存放ETH外设的接口定义和初始化程序以及ETH硬件复位程序，void HAL_ETH_MspInit(ETH_HandleTypeDef* heth)函数由cubemx生成粘贴到.c文件中即可，rtthread会自动调用该函数

lan8720.h内容如下:

这些引脚的宏定义要根据个人使用的板子的原理图的实际的引脚对应关系进行相应的修改

  1. #include "board.h"
  2. #include <rtthread.h>
  3. #include <drivers/pin.h>
  4. /* Private defines --------------------------------------*/
  5. #define ETH_MDC_Pin GPIO_PIN_1
  6. #define ETH_MDC_GPIO_Port GPIOC
  7.  
  8. #define ETH_CRS_DV_Pin GPIO_PIN_7
  9. #define ETH_CRS_DV_GPIO_Port GPIOA
  10.  
  11. #define ETH_RXD0_Pin GPIO_PIN_4
  12. #define ETH_RXD0_GPIO_Port GPIOC
  13.  
  14. #define ETH_RXD1_Pin GPIO_PIN_5
  15. #define ETH_RXD1_GPIO_Port GPIOC
  16.  
  17. #define ETH_REF_CLK_Pin GPIO_PIN_1
  18. #define ETH_REF_CLK_GPIO_Port GPIOA
  19.  
  20. #define ETH_MDIO_Pin GPIO_PIN_2
  21. #define ETH_MDIO_GPIO_Port GPIOA
  22.  
  23. #define ETH_TX_EN_Pin GPIO_PIN_11
  24. #define ETH_TX_EN_GPIO_Port GPIOB
  25.  
  26. #define ETH_TXD1_Pin GPIO_PIN_13
  27. #define ETH_TXD1_GPIO_Port GPIOB
  28.  
  29. #define ETH_TXD0_Pin GPIO_PIN_13
  30. #define ETH_TXD0_GPIO_Port GPIOG
  31.  
  32. //reset GPIO
  33. #define PHY_RST_L_Pin GPIO_PIN_0
  34. #define PHY_RST_L_GPIO_Port GPIOB
  35.  
  36.  
  37. void HAL_ETH_MspInit(ETH_HandleTypeDef* heth);
  38. void phy_reset(void);
lan8720.c文件中内容如下
  1. #define RESET_IO GET_PIN(B, 0)
  2.  
  3.  
  4. void HAL_ETH_MspInit(ETH_HandleTypeDef* heth)
  5. {
  6.     GPIO_InitTypeDef GPIO_InitStruct = {0};
  7.     if(heth->Instance==ETH)
  8.     {
  9.     /* USER CODE BEGIN ETH_MspInit 0 */
  10.  
  11.     /* USER CODE END ETH_MspInit 0 */
  12.       /* Enable Peripheral clock */
  13.       __HAL_RCC_ETH_CLK_ENABLE();
  14.  
  15.       __HAL_RCC_GPIOC_CLK_ENABLE();
  16.       __HAL_RCC_GPIOA_CLK_ENABLE();
  17.       __HAL_RCC_GPIOB_CLK_ENABLE();
  18.       __HAL_RCC_GPIOG_CLK_ENABLE();
  19.       /**ETH GPIO Configuration
  20.       PC1     ------> ETH_MDC
  21.       PA1     ------> ETH_REF_CLK
  22.       PA2     ------> ETH_MDIO
  23.       PA7     ------> ETH_CRS_DV
  24.       PC4     ------> ETH_RXD0
  25.       PC5     ------> ETH_RXD1
  26.       PB11     ------> ETH_TX_EN
  27.       PB13     ------> ETH_TXD1
  28.       PG13     ------> ETH_TXD0
  29.       */
  30.       GPIO_InitStruct.Pin = ETH_MDC_Pin|ETH_RXD0_Pin|ETH_RXD1_Pin;
  31.       GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  32.       GPIO_InitStruct.Pull = GPIO_NOPULL;
  33.       GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  34.       GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  35.       HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  36.  
  37.       GPIO_InitStruct.Pin = ETH_REF_CLK_Pin|ETH_MDIO_Pin|ETH_CRS_DV_Pin;
  38.       GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  39.       GPIO_InitStruct.Pull = GPIO_NOPULL;
  40.       GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  41.       GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  42.       HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  43.  
  44.       GPIO_InitStruct.Pin = ETH_TX_EN_Pin|ETH_TXD1_Pin;
  45.       GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  46.       GPIO_InitStruct.Pull = GPIO_NOPULL;
  47.       GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  48.       GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  49.       HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  50.  
  51.       GPIO_InitStruct.Pin = ETH_TXD0_Pin;
  52.       GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  53.       GPIO_InitStruct.Pull = GPIO_NOPULL;
  54.       GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  55.       GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  56.       HAL_GPIO_Init(ETH_TXD0_GPIO_Port, &GPIO_InitStruct);
  57.  
  58.     /* USER CODE BEGIN ETH_MspInit 1 */
  59. /*      HAL_GPIO_WritePin(PHY_RST_L_GPIO_Port, PHY_RST_L_Pin, GPIO_PIN_RESET);
  60.       HAL_Delay(100);
  61.       HAL_GPIO_WritePin(PHY_RST_L_GPIO_Port, PHY_RST_L_Pin, GPIO_PIN_SET);*/
  62.  
  63.     /* USER CODE END ETH_MspInit 1 */
  64.     }
  65. }
  66.  
  67.  
  68.  
  69. /*void phy_reset(void)
  70. {
  71.     rt_pin_write(reset_pin, 1);
  72.     rt_thread_mdelay(100);
  73.     rt_pin_write(reset_pin, 0);
  74.     rt_thread_mdelay(100);
  75.     HAL_GPIO_WritePin(PHY_RST_L_GPIO_Port, PHY_RST_L_Pin, GPIO_PIN_SET);
  76.     HAL_Delay(100);
  77.     HAL_GPIO_WritePin(PHY_RST_L_GPIO_Port, PHY_RST_L_Pin, GPIO_PIN_RESET);
  78.     rt_thread_mdelay(100);
  79. }*/
  80.  
  81.  
  82. void phy_reset(void)
  83. {
  84.     rt_pin_mode(RESET_IO, PIN_MODE_OUTPUT);
  85.     rt_pin_write(RESET_IO, PIN_HIGH);
  86.     rt_thread_mdelay(50);
  87.     rt_pin_write(RESET_IO, PIN_LOW);
  88.     rt_thread_mdelay(50);
  89.     rt_pin_write(RESET_IO, PIN_HIGH);
  90. }

 说明：phy_reset函数为PHY硬件复位函数，该函数会自动被rtt系统调用，且必须有，如果原理图中该引脚没有接入单片机，则这个函数中的引脚应当如注释中定义一个空脚参与系统调用

3.在board.h文件中将新建的头文件包涵进去

  1. #define BSP_USING_ETH
  2. #ifdef BSP_USING_ETH
  3. #include "lan8720_gpio.h"
  4. #define PHY_USING_LAN8720A
  5. /*#define PHY_USING_DM9161CEP*/
  6. /*#define PHY_USING_DP83848C*/
  7. #endif

 4.打开RT-Thread Setting 进行lwip协议栈配置，并添加网络相关的软件包，如图，

5.组件选项配置

6.示例中勾选TCPserver

7.保存并生成代码，在demo中就能找到tcp服务器的示例代码了

8.下载代码到电路板开启串口控制台，输入tcpserv就可以注册并绑定网卡，开启网络助手就可以进行tcp通信了

9.实际项目中通常需要MCU在上电时自动绑定网卡，建立TCP通信，可以建立一个线程，线程入口函数中将示例中的tcp通信函数内容复制进去并进行修改，建立数据解析和发送功能等；

main.c文件中内容如下
  1. #include <rtthread.h>
  2.  
  3. #define DBG_TAG "main"
  4. #define DBG_LVL DBG_LOG
  5. #include <rtdbg.h>
  6.  
  7. #include "board.h"
  8. #include "stdio.h"
  9. #include "string.h"
  10.  
  11. #include "tcp_server.h"
  12.  
  13. static rt_thread_t my_tid1 = RT_NULL;
  14.  
  15.  
  16. /*static void tcp_thread_entry(void *parameter)
  17. {
  18.     while(1)
  19.     {
  20.         rt_kprintf( "tcp server is runing\r\n");
  21.         rt_thread_mdelay(1000);
  22.     }
  23. }*/
  24.  
  25. int main(void)
  26. {
  27.     my_tid1 = rt_thread_create("tcp_thread",tcpsevr_thread_entry,RT_NULL,2048,10,20);
  28.     if(my_tid1 != RT_NULL)   {rt_thread_startup(my_tid1);}
  29.     return RT_EOK;
  30. }
线程入口函数中内容如下
  1. char SendData[512];
  2. void tcpsevr_thread_entry(void *parameter)
  3. {
  4.     char *recv_data; /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
  5.     socklen_t sin_size;
  6.     int sock, connected, bytes_received;
  7.     struct sockaddr_in server_addr, client_addr;
  8.     rt_bool_t stop = RT_FALSE; /* 停止标志 */
  9.     int ret;
  10.  
  11. /*    uint8_t ip_id = 100;
  12.     char buf[14];
  13.     ip_addr_t ip_addr = {0};*/
  14.  
  15.     recv_data = rt_malloc(BUFSZ + 1); /* 分配接收用的数据缓冲 */
  16.     if (recv_data == RT_NULL)
  17.     {
  18.         rt_kprintf("No memory\n");
  19.         return;
  20.     }
  21.     /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
  22.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  23.     {
  24.         /* 创建失败的错误处理 */
  25.         rt_kprintf("Socket error\n");
  26.         /* 释放已分配的接收缓冲 */
  27.         rt_free(recv_data);
  28.         return;
  29.     }
  30.     /* 初始化服务端地址 */
  31.     server_addr.sin_family = AF_INET;
  32.     server_addr.sin_port = htons(5000);  //服务端工作的端口
  33.     //server_addr.sin_addr.s_addr = ip_addr.addr;
  34.     server_addr.sin_addr.s_addr = INADDR_ANY;
  35.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
  36.     /* 绑定socket到服务端地址 */
  37.     if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
  38.     {
  39.         /* 绑定失败 */
  40.         rt_kprintf("Unable to bind\n");
  41.         /* 释放已分配的接收缓冲 */
  42.         rt_free(recv_data);
  43.         return;
  44.     }
  45.  
  46.     /* 在socket上进行监听 */
  47.     if (listen(sock, 5) == -1)
  48.     {
  49.         rt_kprintf("Listen error\n");
  50.         /* release recv buffer */
  51.         rt_free(recv_data);
  52.         return;
  53.     }
  54.     rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
  55.     while (stop != RT_TRUE)
  56.     {
  57.         sin_size = sizeof(struct sockaddr_in);
  58.  
  59.         /* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
  60.         connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
  61.         /* 返回的是连接成功的socket */
  62.         if (connected < 0)
  63.         {
  64.             rt_kprintf("accept connection failed! errno = %d\n", errno);
  65.             continue;
  66.         }
  67.  
  68.         /* 接受返回的client_addr指向了客户端的地址信息 */
  69.         rt_kprintf("I got a connection from (%s , %d)\n",
  70.                    inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
  71.  
  72.         /* 客户端连接的处理 */
  73.         while (1)
  74.         {
  75.             /* 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据 */
  76.             bytes_received = recv(connected, recv_data, BUFSZ, 0);
  77.             if (bytes_received < 0)
  78.             {
  79.                 /* 接收失败，关闭这个connected socket */
  80.                 closesocket(connected);
  81.                 break;
  82.             }
  83.             else if (bytes_received == 0)
  84.             {
  85.                 /* 打印recv函数返回值为0的警告信息 */
  86.                 rt_kprintf("\nReceived warning,recv function return 0.\r\n");
  87.                 closesocket(connected);
  88.                 break;
  89.             }
  90.  
  91.             /* 有接收到数据，把末端清零 */
  92.             recv_data[bytes_received] = '\0';
  93.             if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
  94.             {
  95.                 /* 如果是首字母是q或Q，关闭这个连接 */
  96.                 closesocket(connected);
  97.                 break;
  98.             }
  99.             else if (strcmp(recv_data, "exit") == 0)
  100.             {
  101.                 /* 如果接收的是exit，则关闭整个服务端 */
  102.                 closesocket(connected);
  103.                 stop = RT_TRUE;
  104.                 break;
  105.             }
  106.             else
  107.             {
  108.                 rt_kprintf("tcp server recved string : %s \n", recv_data);   /* 在控制终端显示收到的数据 */
  109.                 ret = send(connected, recv_data, strlen(recv_data), 0);  //将接收到的数据返回tcp客户端
  110.                 if (ret < 0)
  111.                 {
  112.                     //发送失败，关闭这个连接
  113.                     closesocket(connected);
  114.                     rt_kprintf("\nsend error,close the socket.\r\n");
  115.                     break;
  116.                 }
  117.                 else if (ret == 0)
  118.                 {
  119.                     rt_kprintf("\n Send warning,send function return 0.\r\n");  //  打印send函数返回值为0的警告信息
  120.                 }
  121.             }
  122.         }
  123.     }
  124.     /* 退出服务 */
  125.     closesocket(sock);
  126.     /* 释放接收缓冲 */
  127.     rt_free(recv_data);
  128.     return ;
  129. }

 这里是一个网络数据的回显函数的功能，实际使用效果如下

总结

以上就是今天要讲的内容，本文仅仅简单介绍了使用RT-Thread Studio 配置lan8720+lwip+tcp服务器的建立，并实现了客户端到服务器的数据回显，感谢大家的阅读，有帮助的话请帮博主点点赞，感谢

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

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

  

闽ICP备14008679号