STM32F4+FreeRTOS+LWIP移植

最新推荐文章于 2024-05-04 14:53:27 发布
最新推荐文章于 2024-05-04 14:53:27 发布
阅读量5.2k 收藏 36
点赞数 3
分类专栏： LWIP stm32 文章标签： stm32 freertos 网络协议 tcpip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/numeral_life/article/details/121690779
版权

目录

STM32F407平台实现以太网LWIP+FreeRTOS移植。

以太网（ETH）简介

借助以太网外设，STM32F4xx 可以通过以太网按照 IEEE 802.3-2002 标准发送和接收数据。以太网提供了可配置、灵活的外设，用以满足客户的各种应用需求。它支持与外部物理层(PHY) 相连的两个工业标准接口：默认情况下使用的介质独立接口 (MII)（在 IEEE 802.3 规范中定义）和简化介质独立接口 (RMII)，应用于多种领域，例如交换机、网络接口卡等。
在这里插入图片描述

主要特性

  • MAC 模块对以下系列的系统使用 LAN CSMA/CD 子层：数据速率为 10 Mbit/s 和 100 Mbit/s 的基带系统和宽带系统。支持半双工和全双工工作模式。冲突检测访问方法仅适用于半双工工作模式。支持 MAC 控制帧子层。
  • 符合IEEE 802.3的MII和RMII接口
  • 使用MDIO接口配置和管理最多32个PHY设备
  • 可编程帧长度，支持高达 16 KB 的巨型帧
  • 可编程帧间隔（40-96 位时间，以 8 为步长）
  • 支持多种灵活的地址过滤模式
  • 支持以太网帧时间戳（请参见 IEEE 1588-2008）。每个帧的发送或接收状态下给出 64 位时间戳
  • DMA 具有独立的发送和接收引擎以及相应的 CSR（控制和状态寄存器）空间。发送引擎将数据从系统存储器传送到 Tx FIFO，而接收引擎将数据从 Rx FIFO 传送到系统存储器。DMA可以在 CPU 完全不干预的情况下，通过描述符有效地将数据从源传送到目标。DMA 专为面向包的数据传送（如以太网中的帧）而设计。该控制器经过编程后，可在完成帧发送和接收传送操作时以及其它正常/错误条件下产生 CPU 中断。

LWIP协议栈

LWIP是TCP/IP协议栈的一个开放源代码实现，它由瑞士计算机科学院的Adam Dunkels等开发，目的是减少内存使用率和代码空间大小，因此LWIP适用于运行在资源受限的嵌入式系统环境中。LWIP可以在几百字节或几十KB的RAM空间运行。LWIP既可以移植到操作系统上运行，也可以在无操作系统下独立运行。

LWIP在STM32上的源代码移植

1、core文件：LWIP内核源代码

文件说明
dhcp.c包含DHCP（动态主机配置协议）客户端的实现代码
dns.c包含DNS（域名系统）客户端的实现代码
init.c包含了LWIP协议栈初始化密切相关的函数，以及一些协议栈配置信息的检查和输出
mem.c协议栈内存堆管理函数的实现代码
memp.c协议栈内存池管理函数的实现代码
netif.c包含协议栈网络接口管理的相关函数，协议栈每个接口用一个相对应的结构进行描述
pbuf.c包含协议栈内核使用的数据包管理函数，用于协议栈层次间的数据传递，避免数据拷贝
raw.c原始套接字的实现代码，可以通过该文件中的函数直接操纵IP层数据包
stats.c包含协议栈内部数据统计与显示的函数，比如内存使用状况、邮箱、信号量等信息
sys.c实现对操作系统模拟层的封装，为协议栈提供统一的邮箱、 信号量操作函数。如果开发者需要使用协议栈的sequential API和socket API, 则必须使用底层操作系统提供的邮箱与信号量机制，这时内核要求移植者提供一个称为sys_ arch. c的操作系统模拟层文件,这个文件主要完成对操作系统中邮箱与信号量函数的封装。而sys. c文件的功能是将sys_ arch. c中的函数再次封装，以得到具有协议栈特色的邮箱、信号量操作函数。所谓特色,就是在这些还数中加入一种机制，以实现协议栈中各个定时事件的正确处理。不使用sequential API和socket API时，LWIP 的编程方式是基于回调机制的,因此不需要任何邮箱和信号量机制。
tcp.c包含TCP控制块操作的函数，也包含了TCP定时处理函数
tcp_in.c包含TCP协议数据接收、处理相关的函数，以及最重要的TCP状态机函数
tcp_out.c包含TCP协议数据发送相关函数，例如数据包发送，超时重传函数等
udp.c包含实现UDP协议的相关函数，包括控制块管理、数据包发送函数、数据包接收函数等

2、core/ipv4文件：IPv4标准与IP层数据包相关代码

文件说明
autoip.c包含IP地址自动配置相关函数，若主机从DHCF服务器处获职IP地址失败，则此时主机可以选择启动AUTOIP功能来配置自身的IP地址。AUTOIP将主机配置为169.254.0.0/16中的某个地址，并提供一套完整的机制来避免IP地址冲突
icmp.c包含ICMP (网际控制报文协议) 协议的实现代码。ICMP协议为IE数据包传递过程中的差错报告、差错纠正以及目的地址可达性测试提供了支持,常见的Ping命令就属于ICMP应用中的一种。
igmp.c包含IGMP (网络组管理协议)协议的实现代码。IGMP为网络中的多播数据传输提供了支持，主机加入某个多播组后，可以接收到改组的UDP多播数据。
inet.c包含I层使用到的一-些功能函数的定义,如r地址的转换、网络字节序与主机字节序转换等
inet_chksum.c包含对IP数据包校验相关的函数
ip.c包含IPv4协议实现的相关函数，如数据包的接收、递交、发送等
ip_ addr.c包含-个判断IP地址是否为广播地址的函数
ip_frag.c提供了IP层数据包分片与重组相关的函数

3、api文件：包含sequential API和socket API

文件说明
api_lib.c包含sequential API函数的实现，主要包含预留给用户的编程接口
api.msg.c包含sequential API函数的实现，主要包含API消息的封装和处理函数
netbuf.c包含上层数据包管理函数的实现
netdb.c包含与主机名字转换相关的函数，主要在socket中被使用到
netlfapi.c包含上层网络接口管理函数的实现
sockets.c包含socket API函数的实现
tcpip.c提供了上层API与协议栈内核交互的函徽，它是整个上层API功能得以实现的一个枢纽，其实现的功能可以理解为:从API函数处接收消息，然后将消息递交给内核函数，内核函数根据消息做出相应的处理。

4、netif文件：包含与底层网络接口相关的文件

文件说明
etharp.c包含ARP协议的实现代码。主要用来实现主机以太网物理地址到IP地址的映射。
ethernetif.c包含了与以太网网卡密切相关的初始化、发送、接收等函数的实现。这个文件夹中的函数并不能使用，它们都是一个框架性的结构，移植者需要根据自己使用的网卡特性来完成这些函数。
loopif.c为协议栈提供回环网络接口功能。使用这个接口可以实现本地两个进程之间的数据传递。
slipif.cSLIP (串行链路IP) ,提供一种在串行链路上传送IP数据包的函数定义,移植者需要根据自己使用的串行线路特性来实现这些函数。

修改代码部分

本项目参考自正点原子探索者开发板的网络实验7 NETCONN_UDP实验工程，原工程使用的是ucos_ii+lwip的工程，这里更改为FreeRTOS+lwip的工程并修改。

1、初始化部分

因为原来的工程是初始化时候必须插网线,不插网线初始化就会失败，本工程是把lwip初始化分为两部分，首先是初始化对应的GPIO口和时钟，这部分完成后才可以读取PHY的基本状态寄存器的值。

//初始化接口并使能时钟
void LAN8720_Port_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOG|RCC_AHB1Periph_GPIOD, ENABLE);//使能GPIO时钟 RMII接口
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);   //使能SYSCFG时钟
  
	SYSCFG_ETH_MediaInterfaceConfig(SYSCFG_ETH_MediaInterface_RMII); //MAC和PHY之间使用RMII接口

	/*网络引脚设置 RMII接口
	  ETH_MDIO -------------------------> PA2
	  ETH_MDC --------------------------> PC1
	  ETH_RMII_REF_CLK------------------> PA1
	  ETH_RMII_CRS_DV ------------------> PA7
	  ETH_RMII_RXD0 --------------------> PC4
	  ETH_RMII_RXD1 --------------------> PC5
	  ETH_RMII_TX_EN -------------------> PG11
	  ETH_RMII_TXD0 --------------------> PG13
	  ETH_RMII_TXD1 --------------------> PG14
	  ETH_RESET-------------------------> PD3*/
					
	  //配置PA1 PA2 PA7
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;  
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource1, GPIO_AF_ETH); //引脚复用到网络接口上
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_ETH);
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_ETH);

	//配置PC1,PC4 and PC5
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
	GPIO_PinAFConfig(GPIOC, GPIO_PinSource1, GPIO_AF_ETH); //引脚复用到网络接口上
	GPIO_PinAFConfig(GPIOC, GPIO_PinSource4, GPIO_AF_ETH);
	GPIO_PinAFConfig(GPIOC, GPIO_PinSource5, GPIO_AF_ETH);
                                
	//配置PG11, PG14 and PG13 
	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_11 | GPIO_Pin_13 | GPIO_Pin_14;
	GPIO_Init(GPIOG, &GPIO_InitStructure);
	GPIO_PinAFConfig(GPIOG, GPIO_PinSource11, GPIO_AF_ETH);
	GPIO_PinAFConfig(GPIOG, GPIO_PinSource13, GPIO_AF_ETH);
	GPIO_PinAFConfig(GPIOG, GPIO_PinSource14, GPIO_AF_ETH);
	
	//配置PD3为推完输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;	//推挽输出
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;  
	GPIO_Init(GPIOD, &GPIO_InitStructure);
	
	LAN8720_RST=0;					//硬件复位LAN8720
	delay_ms(50);	
	LAN8720_RST=1;				 	//复位结束 
	
	//使能以太网MAC以及MAC接收和发送时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_ETH_MAC | RCC_AHB1Periph_ETH_MAC_Tx |RCC_AHB1Periph_ETH_MAC_Rx, ENABLE); 
}

然后在创建的lwip_task任务中查询PHY的BSR寄存器的Link Status状态位，当检测到网络连接时再进行tcpip内核初始化和添加网口等操作,如果开启了DHCP服务则在初始化完成后创建dhcp_task的任务。一旦DHCP成功之后，除非系统复位重新初始化，否则不需要重新开启DHCP，即使网线拔下再插入也不会影响继续通信。

//lwip任务
void lwip_task(void *pvParameters)
{
	while(1)
	{
		//查询网络连接状态
		if(Check_Network_connent())
		{
			if(lwip_comm_init())	//有网络连接则初始化lwip
			{
				LCD_ShowString(30,210,200,16,16,"LWIP Init Falied!");   //lwip初始化失败
			}
#if LWIP_DHCP
			lwip_comm_dhcp_creat(); 	//创建DHCP任务
#endif						
			vTaskSuspend(LWIP_Task_Handler);	//初始化完成后挂起自己
		}
		LED1 = !LED1;
		vTaskDelay(200);  //延时200ms
	}
}

//检测网络连接状态
//返回值:0,无网络连接
//       1,有网络连接
u8 Check_Network_connent(void)
{
	if (ETH_ReadPHYRegister(LAN8720_PHY_ADDRESS, PHY_BSR) & PHY_Linked_Status)
		return 1;
	else
		return 0;	
}

2、sys_arch.c文件

操作系统模拟层是LWIP协议栈的一部分，它存在的目的是方便将LWIP移植到不同的操作系统上，它为操作系统和LWIP协议栈之间提供一个接口桥梁，当用户移植到一个新的操作系统的时候，只需要修改操作系统模拟层的各函数即可。Sys_arch.txt文件给出了详细的说明。总的来说，操作系统模拟层主要完成了与信号量、消息邮箱机制、线程相关的功能。
typedef xSemaphoreHandle sys_sem_t; //LWIP信号量类型定义
typedef xQueueHandle sys_mbox_t; //LWIP消息队列类型定义
typedef xTaskHandle sys_thread_t; //LWIP线程类型定义

/*这个文件是操作系统模拟层，是lwip协议栈的一部分。方便将lwip移植到各种不同的操作系统上，为操作系统和lwip协议栈之间
提供一个接口桥梁，当用户移植lwip到一个新的操作系统的时候，只需要修改操作系统模拟层内的各函数即可。lwip使用的消息邮箱
就FreeRTOS中的消息队列这个c文件是信号量、消息队列机制、线程相关的功能的实现代码*/
/* lwIP includes. */
#include "lwip/debug.h"
#include "lwip/def.h"
#include "lwip/lwip_sys.h"
#include "lwip/mem.h"
#include "lwip/stats.h"
#include "FreeRTOS.h"
#include "task.h"
#include "lwip/lwip_timers.h"

xTaskHandle xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;

struct timeoutlist
{
	struct sys_timeouts timeouts;
	xTaskHandle pid;
};

/* This is the number of threads that can be started with sys_thread_new() */
#define SYS_THREAD_MAX 6

static struct timeoutlist s_timeoutlist[SYS_THREAD_MAX];
static u16_t s_nextthread = 0;

/*-----------------------------------------------------------------------------------*/
//  Creates an empty mailbox.
//使用FreeRTOS提供的消息队列机制创建一个空的消息队列（函数xQueueCreate）
err_t sys_mbox_new(sys_mbox_t *mbox, int size)
{
	(void ) size;
	/*创建队列*/
	*mbox = xQueueCreate( archMESG_QUEUE_LENGTH, sizeof( void * ) );

#if SYS_STATS
      ++lwip_stats.sys.mbox.used;
      if (lwip_stats.sys.mbox.max < lwip_stats.sys.mbox.used) {
         lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
	  }
#endif /* SYS_STATS */
 if (*mbox == NULL)
  return ERR_MEM;
 
 return ERR_OK;
}

/*-----------------------------------------------------------------------------------*/
//与sys_mbox_new相反，这个函数用于删除一个队列，当该队列中还有未被取出的消息时，该函数应当报错，并通知应用程序
void sys_mbox_free(sys_mbox_t *mbox)
{
	if( uxQueueMessagesWaiting( *mbox ) )
	{
		/* Line for breakpoint.  Should never break here!报错 */
		portNOP();
#if SYS_STATS
	    lwip_stats.sys.mbox.err++;
#endif /* SYS_STATS */
			
		// TODO notify the user of failure.
	}

	vQueueDelete( *mbox );

#if SYS_STATS
     --lwip_stats.sys.mbox.used;
#endif /* SYS_STATS */
}

/*-----------------------------------------------------------------------------------*/
//   Posts the "msg" to the mailbox.
//该函数用于将消息发送至消息队列中（必须发送成功），是一个阻塞函数。当消息被发送至队列后，该函数才会退出阻塞状态。
void sys_mbox_post(sys_mbox_t *mbox, void *data)
{
	while ( xQueueSendToBack(*mbox, &data, portMAX_DELAY ) != pdTRUE ){}
}


/*-----------------------------------------------------------------------------------*/
//   Try to post the "msg" to the mailbox.
//该函数用于尝试将某个消息发送至消息队列中，当消息被成功投递后，则返回成功，否则返回失败
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
{
err_t result;

   if ( xQueueSendFromISR( *mbox, &msg, 0 ) == pdPASS )
   {
      result = ERR_OK;
   }
   else {
      // could not post, queue must be full
      result = ERR_MEM;
			
#if SYS_STATS
      lwip_stats.sys.mbox.err++;
#endif /* SYS_STATS */
			
   }

   return result;
}

/*-----------------------------------------------------------------------------------*/
/*该函数用于从消息队列中取出一条消息。（等待邮箱中的消息）该函数也是个阻塞函数。调用该函数的线程若未取到消息，则在
形参timeout所指定的时间内，该线程被阻塞。当超过timeout所指定的时间后，该线程恢复至就绪状态。若timeout为0，则调用
该函数的线程一直被阻塞，直到收到消息。*/
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
void *dummyptr;
portTickType StartTime, EndTime, Elapsed;

	StartTime = xTaskGetTickCount();

	if ( msg == NULL )
	{
		msg = &dummyptr;
	}
		
	if ( timeout != 0 )
	{
		if ( pdTRUE == xQueueReceive( *mbox, &(*msg), timeout / portTICK_RATE_MS ) )
		{
			EndTime = xTaskGetTickCount();
			Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;
			
			return ( Elapsed );
		}
		else // timed out blocking for message
		{
			*msg = NULL;
			
			return SYS_ARCH_TIMEOUT;
		}
	}
	else // block forever for a message.
	{
		while( pdTRUE != xQueueReceive( *mbox, &(*msg), portMAX_DELAY ) ){} // time is arbitrary
		EndTime = xTaskGetTickCount();
		Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;
		
		return ( Elapsed ); // return time blocked TODO test	
	}
}

/*-----------------------------------------------------------------------------------*/
/*该函数尝试从消息队列中取出消息，它是一个非阻塞函数。当取到消息时，则返回成功，否则立即退出，返回“队列空” */
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
void *dummyptr;

	if ( msg == NULL )
	{
		msg = &dummyptr;
	}

   if ( pdTRUE == xQueueReceive( *mbox, &(*msg), 0 ) )
   {
      return ERR_OK;
   }
   else
   {
      return SYS_MBOX_EMPTY;
   }
}
/*----------------------------------------------------------------------------------*/
//设置一个消息邮箱为有效
int sys_mbox_valid(sys_mbox_t *mbox)          
{      
  if (*mbox == SYS_MBOX_NULL) 
    return 0;
  else
    return 1;
}                                             
/*-----------------------------------------------------------------------------------*/                                              
//设置一个消息邮箱为无效
void sys_mbox_set_invalid(sys_mbox_t *mbox)   
{                                             
  *mbox = SYS_MBOX_NULL;                      
}                                             

/*-----------------------------------------------------------------------------------*/
//  Creates a new semaphore. The "count" argument specifies
//  the initial state of the semaphore.
//该函数用于创建一个信号量，其中形参count指明了当前信号量的状态。若count为0，则该信号量在创建时就被
//”取走“了
err_t sys_sem_new(sys_sem_t *sem, u8_t count)
{
	//创建二进制信号量
	vSemaphoreCreateBinary(*sem );
	if(*sem == NULL)
	{
#if SYS_STATS
      ++lwip_stats.sys.sem.err;
#endif /* SYS_STATS */	
		return ERR_MEM;
	}
	
	if(count == 0)	// Means it can't be taken
	{
		xSemaphoreTake(*sem,1);
	}

#if SYS_STATS
	++lwip_stats.sys.sem.used;
 	if (lwip_stats.sys.sem.max < lwip_stats.sys.sem.used) {
		lwip_stats.sys.sem.max = lwip_stats.sys.sem.used;
	}
#endif /* SYS_STATS */
		
	return ERR_OK;
}

/*-----------------------------------------------------------------------------------*/
*/该函数是一个阻塞函数，（等待一个信号量）调用该函数的线程在形参timeout指定的时间内被阻塞。若timeout为0，则调用
该函数的线程将一直被阻塞，直到等待的信号量被释放。当该函数取到信号量时，它将返回取得该信号量所占用的时间。*/
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
{
portTickType StartTime, EndTime, Elapsed;

	StartTime = xTaskGetTickCount();

	if(	timeout != 0)
	{
		if( xSemaphoreTake( *sem, timeout / portTICK_RATE_MS ) == pdTRUE )
		{
			EndTime = xTaskGetTickCount();
			Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;
			
			return (Elapsed); // return time blocked TODO test	
		}
		else
		{
			return SYS_ARCH_TIMEOUT;
		}
	}
	else // must block without a timeout
	{
		while( xSemaphoreTake(*sem, portMAX_DELAY) != pdTRUE){}
		EndTime = xTaskGetTickCount();
		Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;

		return ( Elapsed ); // return time blocked	
		
	}
}

/*-----------------------------------------------------------------------------------*/
// Signals a semaphore
//该函数用于发送一个信号量
void sys_sem_signal(sys_sem_t *sem)
{
	xSemaphoreGive(*sem);
}

/*-----------------------------------------------------------------------------------*/
// Deallocates a semaphore
//该函数用于释放并删除一个信号量
void sys_sem_free(sys_sem_t *sem)
{
#if SYS_STATS
      --lwip_stats.sys.sem.used;
#endif /* SYS_STATS */
			
	vQueueDelete(*sem);
}
/*-----------------------------------------------------------------------------------*/
//查询一个信号量的状态，无效或有效
int sys_sem_valid(sys_sem_t *sem)                                               
{
  if (*sem == SYS_SEM_NULL)
    return 0;
  else
    return 1;                                       
}

/*-----------------------------------------------------------------------------------*/                                                                                                                                                                

void sys_sem_set_invalid(sys_sem_t *sem)                                        
{                                                                               
  *sem = SYS_SEM_NULL;                                                          
} 

/*-----------------------------------------------------------------------------------*/
// Initialize sys arch
//该函数是操作系统模拟层的初始化函数。它主要对定时器管理数组进行了初始化。（可能用不到）
void sys_init(void)
{
	int i;

	// Initialize the the per-thread sys_timeouts structures
	// make sure there are no valid pids in the list
	for(i = 0; i < SYS_THREAD_MAX; i++)
	{
		s_timeoutlist[i].pid = 0;
		s_timeoutlist[i].timeouts.next = NULL;
	}
	
	// keep track of how many threads have been created
	s_nextthread = 0;
}

/*-----------------------------------------------------------------------------------*/
/*该函数用于返回当前任务的定时器管理链表首地址。*/
struct sys_timeouts *sys_arch_timeouts(void)
{
int i;
xTaskHandle pid;
struct timeoutlist *tl;

	pid =  xTaskGetCurrentTaskHandle();
              

	for(i = 0; i < s_nextthread; i++)
	{
		tl = &(s_timeoutlist[i]);
		if(tl->pid == pid)
		{
			return &(tl->timeouts);
		}
	}

	// Error
	return NULL;
}

/*-----------------------------------------------------------------------------------*/
                                      /* Mutexes*/
/*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
#if LWIP_COMPAT_MUTEX == 0
/* Create a new mutex*/
err_t sys_mutex_new(sys_mutex_t *mutex) {

  *mutex = xSemaphoreCreateMutex();
		if(*mutex == NULL)
	{
#if SYS_STATS
      ++lwip_stats.sys.mutex.err;
#endif /* SYS_STATS */	
		return ERR_MEM;
	}

#if SYS_STATS
	++lwip_stats.sys.mutex.used;
 	if (lwip_stats.sys.mutex.max < lwip_stats.sys.mutex.used) {
		lwip_stats.sys.mutex.max = lwip_stats.sys.mutex.used;
	}
#endif /* SYS_STATS */
        return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
/* Deallocate a mutex*/
void sys_mutex_free(sys_mutex_t *mutex)
{
#if SYS_STATS
      --lwip_stats.sys.mutex.used;
#endif /* SYS_STATS */
			
	vQueueDelete(*mutex);
}
/*-----------------------------------------------------------------------------------*/
/* Lock a mutex*/
void sys_mutex_lock(sys_mutex_t *mutex)
{
	sys_arch_sem_wait(*mutex, 0);
}

/*-----------------------------------------------------------------------------------*/
/* Unlock a mutex*/
void sys_mutex_unlock(sys_mutex_t *mutex)
{
	xSemaphoreGive(*mutex);
}
#endif /*LWIP_COMPAT_MUTEX*/
/*-----------------------------------------------------------------------------------*/
// TODO
/*-----------------------------------------------------------------------------------*/
/*该函数用于创建一个新的线程。其中，形参name指定了该线程的名称，thread是该线程对应的函数，arg是该线程的
形参，stacksize指定了该线程对应的堆栈大小，prio则指定了该线程的优先级。 （一般用来创建一个内核任务）*/
sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread , void *arg, int stacksize, int prio)
{
xTaskHandle CreatedTask;
int result;

   if ( s_nextthread < SYS_THREAD_MAX )
   {
      result = xTaskCreate( thread, ( portCHAR * ) name, stacksize, arg, prio, &CreatedTask );

	   // For each task created, store the task handle (pid) in the timers array.
	   // This scheme doesn't allow for threads to be deleted
	   s_timeoutlist[s_nextthread++].pid = CreatedTask;

	   if(result == pdPASS)
	   {
		   return CreatedTask;
	   }
	   else
	   {
		   return NULL;
	   }
   }
   else
   {
      return NULL;
   }
}

/*该函数用于保护临界区资源。*/
sys_prot_t sys_arch_protect(void)
{
	//vPortEnterCritical();
	taskENTER_CRITICAL_FROM_ISR();//中断进入临界保护
	return 1;
}

/*该函数在访问临界区资源时使用，它必须与sys_arch_protect函数成对使用。*/
void sys_arch_unprotect(sys_prot_t pval)
{
//	( void ) pval;
//	vPortExitCritical();
	taskEXIT_CRITICAL_FROM_ISR(pval);//中断退出临界保护
}

/*
 * Prints an assertion messages and aborts execution.
 */
void sys_assert( const char *msg )
{	
	( void ) msg;
	/*FSL:only needed for debugging
	printf(msg);
	printf("\n\r");
	*/
    vPortEnterCritical(  );
    for(;;)
    ;
}

3、UDP通信线程

//UDP客户端任务
#define UDP_TASK_PRIO 		6
//任务堆栈大小
#define UDP_STK_SIZE		300	
//任务句柄
TaskHandle_t UDP_Task_Handler;
//任务函数
void udp_thread(void *pdata);  

u8 udp_demo_recvbuf[UDP_DEMO_RX_BUFSIZE];	//UDP接收数据缓冲区
//UDP发送数据内容
const u8 *udp_demo_sendbuf="Explorer STM32F407 NETCONN UDP demo send data\r\n";
u8 udp_flag;							//UDP数据发送标志位

//udp任务函数
void udp_thread(void *pdata)
{
	err_t err;
	static struct netconn *udpconn;
	static struct netbuf  *recvbuf;
	static struct netbuf  *sentbuf;
	struct ip_addr destipaddr;
	u32 data_len = 0;
	struct pbuf *q;
	
	LWIP_UNUSED_ARG(pdata);
	udpconn = netconn_new(NETCONN_UDP);  //创建一个UDP链接
	udpconn->recv_timeout = 10;  		
	
	if(udpconn != NULL)  //创建UDP连接成功
	{
		err = netconn_bind(udpconn,IP_ADDR_ANY,UDP_DEMO_PORT); 
		IP4_ADDR(&destipaddr,lwipdev.remoteip[0],lwipdev.remoteip[1], lwipdev.remoteip[2],lwipdev.remoteip[3]); //构造目的IP地址
		netconn_connect(udpconn,&destipaddr,UDP_DEMO_PORT); 	//连接到远端主机
		if(err == ERR_OK)//绑定完成
		{
			while(1)
			{
				if((udp_flag & LWIP_SEND_DATA) == LWIP_SEND_DATA) //有数据要发送
				{
					sentbuf = netbuf_new();
					netbuf_alloc(sentbuf,strlen((char *)udp_demo_sendbuf));
					memcpy(sentbuf->p->payload,(void*)udp_demo_sendbuf,strlen((char*)udp_demo_sendbuf));
					err = netconn_send(udpconn,sentbuf);  	//将netbuf中的数据发送出去
					if(err != ERR_OK)
					{
						printf("发送失败\r\n");
						netbuf_delete(sentbuf);      //删除buf
					}
					udp_flag &= ~LWIP_SEND_DATA;	//清除数据发送标志
					netbuf_delete(sentbuf);      	//删除buf
				}	
				
				netconn_recv(udpconn,&recvbuf); //接收数据
				if(recvbuf != NULL)          //接收到数据
				{ 
					taskENTER_CRITICAL();    //进入临界区
					memset(udp_demo_recvbuf,0,UDP_DEMO_RX_BUFSIZE);  //数据接收缓冲区清零
					for(q=recvbuf->p;q!=NULL;q=q->next)  //遍历完整个pbuf链表
					{
						//判断要拷贝到UDP_DEMO_RX_BUFSIZE中的数据是否大于UDP_DEMO_RX_BUFSIZE的剩余空间，如果大于
						//的话就只拷贝UDP_DEMO_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据
						if(q->len > (UDP_DEMO_RX_BUFSIZE-data_len)) memcpy(udp_demo_recvbuf+data_len,q->payload,(UDP_DEMO_RX_BUFSIZE-data_len));//拷贝数据
						else memcpy(udp_demo_recvbuf+data_len,q->payload,q->len);
						data_len += q->len;  	
						if(data_len > UDP_DEMO_RX_BUFSIZE) break; //超出TCP客户端接收数组,跳出	
					}
					taskEXIT_CRITICAL();      //退出临界区
					data_len=0;  //复制完成后data_len要清零。
					printf("%s\r\n",udp_demo_recvbuf);  //打印接收到的数据
					netbuf_delete(recvbuf);      //删除buf
				}else vTaskDelay(5);  //延时5ms
			}
		}else printf("UDP绑定失败\r\n");
	}else printf("UDP连接创建失败\r\n");
}


//创建UDP线程
//返回值:0 UDP创建成功
//		其他 UDP创建失败
void udp_demo_init(void)
{
	taskENTER_CRITICAL();    //进入临界区

	//创建UDP线程
	xTaskCreate((TaskFunction_t )udp_thread,  		//任务函数
              (const char*    )"UDP_Thread",        //任务名称
              (uint16_t       )UDP_STK_SIZE,      	//任务堆栈大小
              (void*          )NULL,                //传递给任务函数的参数
              (UBaseType_t    )UDP_TASK_PRIO,    	//任务优先级
              (TaskHandle_t*  )&UDP_Task_Handler);	//任务句柄 
	taskEXIT_CRITICAL();     //退出临界区
}

4、以太网配置

因为原来的以太网中断设置为最高优先级0，而我们给FreeRTOS系统可管理的最高中断优先级设置的是5，会导致port.c文件的configASSERT调用断言，需要对其进行更改。

代码下载链接: STM32F4+FreeRTOS+LwIP.zip.

Numeral_Life
关注
  • 3
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初识 FreeRTOS + lwip
Zpeg的博客
12-20 6646
本文是对一些对Linux等系统有认识，但却没有接触过FreeRTOS系统的人提供一些帮助，能够了解FreeRTOS大致的一些工作原理和如何在FreeRTOS系统上开发还有网络协议栈实现等。作者对于FreeRTOS开发时间还不长，发现文中有哪些谬误，烦劳指出不胜感谢。本文大致分为以下几部分： Preface 主要描述RTOS与通用系统之间的区别和FreeRTOS系统的特性 Task Manage...
STM32F4XX LWIP+freeRTOS移植(一)
热门推荐
u014453443的博客
08-01 1万+
有疑问请加扣扣技术交流群：460189483 源码下载地址：https://download.csdn.net/download/u014453443/10698059 TM32F429IGT6原子开发板进行验证的，PHY芯片为LAN8720 原子哥的程序都是ucos_ii+lwip的工程，没有freeRTOS+lwip的工程，这里对比二种系统的差异，来进行lwip的freeRTOS的移植 ...
STM32F4+FreeRTOS+LwIP移植
12-17
正点原子探索者开发板STM32F4+FreeRTOS+LWIP移植工程，包含DHCP、UDP、TCP Client、TCP Server。
STM32F4以太网LWIP - LAN8720
最新发布
Cyber-Spider的博客
05-04 1815
TCP/IP是一个协议簇，包含众多网络协议如TCP、IP、HTTP、FTP、MQTT、UDP、HRP、DHCP、DNS等等STM32F407自带有10/100Mbits/s数据传输速率的以太网内核(以太网网络接口卡的控制器，负责以太网中数据帧的发送和接收)，这个以太网MAC内核有如下特性：1.支持外部PHY接口(以太网外部端口芯片，如LAN8720)实现10/100Mbit/s数据传输速率2.通过符合IEEE802.3的MII接口与外接的快速以太网PHY进行通信。
基于FREERTOS系统的LWIP协议移植（STM32F1战舰版）
zhuhongtu94的博客
05-21 3695
文章目录前言FREERTOS系统介绍FREERTOS系统之API函数1.创建任务函数xTaskCreate()2.删除任务函数xTaskDelete()5.释放信号量函数xSemaphoreGive()、xSemaphoreGiveISR()6.创建互斥信号量函数xSemaphoreCreateMutex()FREERTOS系统移植LWIP协议介绍LWIP协议移植 本次项目开发平台为STM32战舰版 （也是对上一博客说明） 前言 FREERTOS是由safeRTOS衍生的一套操作系统，由Richard Ba
STM32F407 FreeRTOS+LWIP移植
theskyisbluebut的博客
02-28 4835
本文基于STM32F4 LWIP开发手册V3.0中第二章LWIP带操作系统移植和STM32F4 FreeRTOS开发手册_V1.1.并参照博客文章STM32F4XX LWIP+freeRTOS移植(一)_u014453443的博客-CSDN博客_freertos lwip 类似于UCOS+LWIP的移植，需要在sys_arch.c中为协议栈提供邮箱、信号量等机制，并在sys_arch.h中封装定义信号量和消息邮箱。此外，在sys_arch.c中针对邮箱，信号量机制需实现的函数正点原子官方已经在lwip_s
STM32F4+FreeRTOS+FATFS+LWIP工程，实现FTP服务器功能
ciipeteryang的博客
12-29 2278
近期因项目需要，用stm32f4芯片，与linux或windows系统进行通信，通过FTP协议发送和接收文件，实现双机系统通信，在stm32f4项目中，移植了FreeRTOS系统，移植了Fatfs文件系统，和LWIP网络协议栈。基于操作系统的网络协议栈功能，使用socket通信方式建立ftp连接。
STM32F4x7+freertos+lwip+ssl+MQTT-(MDK5)稳定可靠
12-11
这是公司实际项目工程（编译器用DK5）,STM32F4x7+freertos+lwip+ssl+MQTT，其中MQTT自己花了一个礼拜移植，可以同时发布消息和订阅消息（发布主题：DongLuTest，订阅主题：mymqttsubtest），经过长期测试MQTT运行...
stm32f4xx+freeRTOS+LWIP移植
09-30
这个"stm32f4xx+freeRTOS+LWIP移植"项目提供了一个亲测可用的移植实例，可以帮助开发者快速理解和实践上述知识点。在实际应用中，还需要考虑功耗、安全性、实时性等多方面因素，以适应不同的应用场景。
stm32单片机与FreeRTOS、LwIP内存堆栈使用情况分析
andre_ww的博客
05-24 1864
内存池是指为了满足特定内存分配的需要以及优化内存占用，制定了各种尺寸大小的内存池（每种内存池管理的内存块大小固定）。内存堆本质上是一大块连续内存（可以理解为数组），当需要内存时就从这个数组中按照特定算法切分一块所需大小的内存块，将这块内存的地址提供出去；栈（STACK）：在单片机中，栈的作用与在计算机上运行的程序的栈类似，用于存储函数调用的局部变量、参数和返回地址等信息。堆（HEAP）：在单片机中，堆的作用与在计算机上运行的程序的堆类似，用于动态分配内存。内存堆的实现同理，两者可以并存。
STM32F4基于FreeRTOS的lwip移植
08-21
硬件是基于正点原子探索者开发板，软件是基于最简单的stm32的FreeRTOS版本工程demo来移植的官方的lwip引用,tcp/udp/web分别单独的文件中，使用简单，代码容易看懂。
STM32F407+FreeRTOS+LAN8720+LWIP1.4.1+DHCP+标准库+MDK5
07-23
本例程是依据正点原子STM32F4探索者开发板的平台上，使用标准库，MDK5工程。参考了大神移植说明https://blog.csdn.net/u014453443/article/details/81328222，同时参考《ALIENTEK STM32F4 LWIP的开发手册》，实现了FreeRTOS的LWIP移植，以及DHCP功能的工程。可直接运行在正点原子探索者开发板平台上。
STM32F4xx-FreeRTOS-LWIP移植工程
06-14
本次工程基于STM32F4系列进行移植的，不需要LCD以及外部SRAM正常使用，综合移植FreeRTOS和LWIP，亲测通过DHCP获取IP地址成功能
STM32+freeRTOS+LWIP实现TCP Server并发监听多个客户端的方法
zyl87的专栏
09-03 5407
STM32 FreeRTOS+LWIP实现TCP Server并发连接
【FreeRTOS】基于STM32移植LWIP 2.1.2详细步骤
ZHONGCAI0901的博客
11-09 9795
文章目录1. 前言2. STM32运行LwIP的系统框图3. LwIP RTOS部分的移植4. LwIP System Config的移植 1. 前言 在STM32平台移植LWIP 2.1.2功能，首先需要做一些准备工作，例如： 下载资料：lwip-2.1.2、contrib-2.1.0、STM32F4x7_ETH_LwIP_V1.1.1，参考：《基于STM32移植LWIP的资料准备》 准备好已经在STM32移植好的FreeRTOS的工程。 移植的目标平台是STM32F429，在以前资料准备中有提到ST
基于FreeRTOS与MQTT的物联网技术应用系列——步进电机控制（四）FreeRTOS系统下LwIP-1.4.1的移植
sqshining的专栏
09-26 9849
本文在前一篇的基础上，进行基于FreeRTOS的LwIP-1.4.1版本移植
STM32407 FreeRtos系统下lwip实现发送和接收数据包进行链路测试
m0_59949484的博客
05-17 2310
3）配置以太网：使用MAC和PHY通信，选择RMII接口，将ETH1引脚分别连接到RST、REF_CLK、RXD0、RXD1、TXD0和TXD1引脚。在实现过程中，还可以考虑使用一些额外的功能和服务，例如DHCP、DNS、SNMP、HTTP等。实现数据包发送和接收功能：使用lwIP提供的API函数实现基本的网络通信功能，例如发送和接收UDP数据包或TCP连接。5）添加lwIP：选择使用STM32CubeMX生成的代码，将lwIP配置为DHCP客户端，生成相应的代码。
STM32F4XX LWIP+freeRTOS移植(一)
weixin_40333655的博客
09-27 465
有疑问请加扣扣技术交流群：460189483 源码下载地址：https://download.csdn.net/download/u014453443/10698059 STM32F407+FreeRTOS+LAN8720+LWIP1.4.1+DHCP+UDP+标准库+MDK5 TM32F429IGT6原子开发板进行验证的，PHY芯片为LAN8720 原子哥的程序都是ucos_ii+lwip的工程，没有freeRTOS+lwip的工程，这里对比二种系统的差异，来进行lwip的freeRTOS的移植 LWIP
STM32CubeMX+STM32F407+FreeRTos+LWIP+LAN8720
09-06
您好！对于 STM32F407 微控制器，您可以使用 STM32CubeMX 进行初始化配置。STM32CubeMX 是一个开发工具，可帮助您生成基于 STM32 微控制器系列的初始化代码。 对于 FreeRTOS，它是一个用于嵌入式系统的开源实时操作系统。您可以将 FreeRTOS 集成到您的项目中，以便管理任务调度和并发性。 LWIP 是一个轻量级的 TCP/IP 协议栈，适用于嵌入式系统。您可以使用 LWIP 实现网络通信功能。 LAN8720 是一款高性能的嵌入式以太网物理层收发器芯片。它可以与 STM32 微控制器配合使用，实现以太网通信功能。 如果您有任何关于 STM32CubeMX、FreeRTOS、LWIP 或 LAN8720 的具体问题，欢迎向我提问！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值