STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细

这篇具有很好参考价值的文章主要介绍了STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

工程环境:

MCU:STM32H723ZGT

ETH PHY :DP83848

RT-Thread:RT-Thread nano 3.1.5

Software Pack:STM32CubeH7 Firmware Package V1.10.0 / 11-February-2022

参考文章:

STM32H723配置以太网+Freertos注意事项

STM32H723+Lwip+ETH+CUBE 完整配置(排了巨多坑!)

Cube配置STM32H743+DP83848以太网工程

STM32H743+CubeMX-梳理MPU的设置

前言:

首先使用CubeMX配置相关外设和软件代码,导出Keil MDK工程,然后在Keil中修改相关代码。

内存规划:

D2域SRAM1(0x30000000-0x30000200 , 512B)存放ETH DMA的Rx描述符

D2域SRAM1(0x30000200-0x30000400 , 512B)存放ETH DMA的Tx描述符

D2域SRAM1(0x30000400-0x30004000 , 15KB)存放LWIP的RX_POOL内存池

D2域SRAM2(0x30004000-0x30008000 , 16KB)存放LWIP的内存堆

这里LWIP的RX_POOL内存池和内存堆不只局限于D2域,也可以放在D1域的AXI SRAM,AXI SRAM默认有320KB,大很多,但是不能放在DTCM中,因为ETH DMA无法访问DTCM。

注意:ETH DMA的Rx描述符和Tx描述符只能放在D2域。

我们这里把内存池和内存堆独立配置,LWIP还支持将内存池由内存堆实现,将内存堆由内存池实现。

一、CubeMX配置:

ETH外设配置:

选择ETH外设;

我这里使用的是MII接口,请根据实际情况选择;

配置ETH外设的MAC地址和ETH DMA描述符;

Ethernet MAC Address  :配置MAC地址;

Tx Descriptor Length  :ETH DMA Tx描述符长度,这里默认4个,后期可以在代码中修改;

First Tx Descriptor Address  :首个ETH DMA Tx描述符地址,这个地址必须是D2域的SRAM地址,这里配置为0x30000200

Rx Descriptor Length  :ETH DMA Rx描述符长度,这里默认4个,后期可以在代码中修改;

First Rx Descriptor Address  :首个ETH DMA Rx描述符地址,这个地址必须是D2域的SRAM地址,这里配置为0x30000000

Rx Buffers Length:Rx缓冲区长度,配置为1528

ETH DMA的描述符1个是24字节,这里分别把TX和RX配置为4个,也就是分别用了96字节,而我们分配的空间分别是512字节,最多可以配置512/4=21个,实际用不了这么多,剩余的空间就预留后期拓展吧,在配置MPU的时候要把这1KB(0x30000000-0x30000400 )单独保护起来。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

开启ETH全局中断 STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 根据实际情况配置以太网外设的GPIO,并将所有使用的GPIO配置为高速;

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

添加PHY芯片的复位引脚,我这里用的是PF13,将PF13配置为上拉推挽输出模式,默认输出高电平。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 MPU配置

D2域SRAM主要用于LWIP的RX_POOL内存池和内存堆,存放以太网接收和发送的数据,这里不缓存这个区域;

 D2域的0x30000000-0x30000400 这1KB用于存放ETH DMA的描述符,这里配置为共享设备模式。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 RTOS配置

STM32CubeMX也支持添加RT-Thread,需要手动安装软件包,但是STM32CubeMX不会生成LWIP与操作系统相关的代码,主要就是线程、信号量、邮箱、互斥锁等相关的代码,在这里我们先启用STM32CubeMX里的FreeRTOS操作系统,导出工程文件后在Keil里移除FreeRTOS,然后添加RT-Thread,并将LWIP与操作系统相关的代码替换成RT-Thread的代码。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

LWIP配置

这里把LWIP的内存堆放在D2域的SRAM2中(0x30004000-0x30008000),LWIP的可用内存堆大小MEM_SIZE配置为14KB。

LWIP的内存堆也可以放在D1域的AXI SRAM中,但是不能放在DTCM中,因为ETH DMA无法访问DTCM。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

配置TCPIP线程:

 将TCPIP线程的优先级设高点,在RT-Thread中数字越小优先级越高。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 配置IP地址:

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

选择PHY芯片:

这里只能选择LAN8742,由于我们用的是DP83848,后面我们在代码中修改一下PHY的地址。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

串口配置

这里开启USART1用于输出调试信息,根据实际情况配置。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

HAL库时钟配置

默认使用系统定时器SysTick

RCC时钟配置

启用外部HSE时钟

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 时钟树根据实际使用情况配置

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

导出Keil工程

这里选择仅拷贝使用的库代码,将每个外设初始化代码放在单个文件中,开启修改备份。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

二、 Keil代码修改

修改PHY地址寄存器:

DP83848的PHY地址是在PHYCR(0x19)这个寄存器中,打开lan8742.c文件,找到int32_t LAN8742_Init(lan8742_Object_t *pObj)函数,将图中第107行代码这里改成0x19。程序中是通过循环读取PHYCR(0x19)寄存器,直到读出的地址与addr匹配为止。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

修改获取链路状态函数

LAN8742的链路状态是在地址为31的寄存器中,而DP83848在PHYSTS寄存器(地址0x10)中,

所以需要修改 LAN8742_GetLinkState() 函数,

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 修改后如下:

/**
  * @brief  Get the link state of LAN8742 device.
  * @param  pObj: Pointer to device object. 
  * @param  pLinkState: Pointer to link state
  * @retval LAN8742_STATUS_LINK_DOWN  if link is down
  *         LAN8742_STATUS_AUTONEGO_NOTDONE if Auto nego not completed 
  *         LAN8742_STATUS_100MBITS_FULLDUPLEX if 100Mb/s FD
  *         LAN8742_STATUS_100MBITS_HALFDUPLEX if 100Mb/s HD
  *         LAN8742_STATUS_10MBITS_FULLDUPLEX  if 10Mb/s FD
  *         LAN8742_STATUS_10MBITS_HALFDUPLEX  if 10Mb/s HD       
  *         LAN8742_STATUS_READ_ERROR if connot read register
  *         LAN8742_STATUS_WRITE_ERROR if connot write to register
  */
int32_t LAN8742_GetLinkState(lan8742_Object_t *pObj)
{
  uint32_t readval = 0;
  
  /* Read Status register */
  if(pObj->IO.ReadReg(pObj->DevAddr, LAN8742_BSR, &readval) < 0)
  {
    return LAN8742_STATUS_READ_ERROR;
  }
  
  /* Read Status register again */
  if(pObj->IO.ReadReg(pObj->DevAddr, LAN8742_BSR, &readval) < 0)
  {
    return LAN8742_STATUS_READ_ERROR;
  }
  
  if((readval & LAN8742_BSR_LINK_STATUS) == 0)
  {
    /* Return Link Down status */
    return LAN8742_STATUS_LINK_DOWN;    
  }
  
  /* Check Auto negotiaition */
  if(pObj->IO.ReadReg(pObj->DevAddr, LAN8742_BCR, &readval) < 0)//读取基本控制寄存器0x00
  {
    return LAN8742_STATUS_READ_ERROR;
  }
  
  if((readval & LAN8742_BCR_AUTONEGO_EN) != LAN8742_BCR_AUTONEGO_EN) //未启用自动协商
  {
    if(((readval & LAN8742_BCR_SPEED_SELECT) == LAN8742_BCR_SPEED_SELECT) && ((readval & LAN8742_BCR_DUPLEX_MODE) == LAN8742_BCR_DUPLEX_MODE)) 
    {
      return LAN8742_STATUS_100MBITS_FULLDUPLEX;
    }
    else if ((readval & LAN8742_BCR_SPEED_SELECT) == LAN8742_BCR_SPEED_SELECT)
    {
      return LAN8742_STATUS_100MBITS_HALFDUPLEX;
    }        
    else if ((readval & LAN8742_BCR_DUPLEX_MODE) == LAN8742_BCR_DUPLEX_MODE)
    {
      return LAN8742_STATUS_10MBITS_FULLDUPLEX;
    }
    else
    {
      return LAN8742_STATUS_10MBITS_HALFDUPLEX;
    }  		
  }
  else /* Auto Nego enabled */
  {
    //DP83848
    if(pObj->IO.ReadReg(pObj->DevAddr, 0x10, &readval) < 0) //DP83848,PHY状态寄存器(PHYSTS) 地址0x10
    {
      return LAN8742_STATUS_READ_ERROR;
    }
      
    /* Check if auto nego not done */
    if((readval & 0x0010) == 0) //bit4, Auto-Negotiation Complete
    {
      return LAN8742_STATUS_AUTONEGO_NOTDONE;//自动协商未完成
    }
    
    if((readval & 0x0006) == 0x04)//bit2,bit1,  100 Mb/s mode,Full duplex mode
    {
      return LAN8742_STATUS_100MBITS_FULLDUPLEX;
    }
    else if ((readval & 0x0006) == 0x00)//bit2,bit1,  100 Mb/s mode,Half duplex mode.
    {
      return LAN8742_STATUS_100MBITS_HALFDUPLEX;
    }
    else if ((readval & 0x0006) == 0x06)//bit2,bit1,  10 Mb/s mode,Half duplex mode.
    {
      return LAN8742_STATUS_10MBITS_FULLDUPLEX;
    }
    else
    {
      return LAN8742_STATUS_10MBITS_HALFDUPLEX; //10 Mb/s mode,Half duplex mode.
    }				
  }
}

添加PHY芯片复位代码:

打开ethernetif.c文件,找到static void low_level_init(struct netif *netif)函数,在这里添加PHY复位代码,我这里用的是PF13,根据实际情况修改。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

添加LWIP的RX_POOL内存池定位代码

打开cc.h文件,

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

注释这行代码,防止编译时报错。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

在文件末尾添加如下代码,将memp_memory_RX_POOL_base这个数组定位到D2域SRAM1中,由于前1KB用于存放ETH DMA描述符了,所以从0x30000400开始,一共15KB。

/* USER CODE BEGIN 0 */                                    
#if defined ( __ICCARM__ ) /*!< IAR Compiler */
#pragma location = 0x30000400
extern unsigned char memp_memory_RX_POOL_base[];

#elif defined ( __CC_ARM )  /* MDK ARM Compiler */
__attribute__((at(0x30000400))) extern unsigned char memp_memory_RX_POOL_base[];

#elif defined ( __GNUC__ ) /* GNU Compiler */
extern unsigned char memp_memory_RX_POOL_base[] __attribute__((section(".Rx_PoolSection")));
#endif 
/* USER CODE END 0 */

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

如果想要把RX_POOL内存池放到别的地方,如果用的是AC5编译器,则修改上图中第94行代码,如果用的是AC6编译器,则需要修改分散加载文件。

AC6编译器修改方式如下:

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 分散加载文件内容如下:

; *************************************************************
; *** Scatter-Loading Description File generated by uVision ***
; *************************************************************

LR_IROM1 0x08000000 0x00100000  {    ; load region size_region
  ER_IROM1 0x08000000 0x00100000  {  ; load address = execution address
   *.o (RESET, +First)
   *(InRoot$$Sections)
   .ANY (+RO)
   .ANY (+XO)
  }
  RW_IRAM1 0x20000000 0x00020000  {  ; RW data
   .ANY (+RW +ZI)
  }
  RW_IRAM2 0x24000000 0x00050000  {
   .ANY (+RW +ZI)
  }
  
  RW_IRAM3 0x30000000 0x00000200  {  ; 512B - SRAM1 存放ETH DMA RX描述符
   .ANY(.RxDecripSection)
  }
  
  RW_IRAM4 0x30000200 0x00000200  {  ; 512B - SRAM1 存放ETH DMA TX描述符
   .ANY(.TxDecripSection)
  }
  
  RW_IRAM5 0x30000400 0x00003C00  {  ; 15KB - SRAM1 存放RX_POOL内存池
   .ANY(.Rx_PoolSection)
  }
}

由于这里配置的RX_POOL内存池的大小只有15KB,还需要修改 ethernetif.c 文件中ETH_RX_BUFFER_CNT 宏的大小,15KB大约能分配9个ETH_RX_BUFFER 。

#define ETH_RX_BUFFER_CNT             9U

 STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

此时编译整个工程,下载程序到板子就能ping通了。

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

到此整个系统可以工作了,下面是将FreeRTOS替换成RT-Thread


三、移除FreeRTOS代码

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 将FreeRTOS的文件包含目录删除

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

Ctrl+F 查找 cmsis_os.h,凡是包含了cmsis_os.h这个头文件的文件,全部注释掉

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 

四、添加RT-Thread

 为了省事,这里直接使用Keil的包管理器(需要先安装RT-Thread Pack),添加RT-Thread,

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 

打开board.c,添加头文件和外部函数声明,

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 

#include "main.h"

extern HAL_StatusTypeDef HAL_Init(void);
extern void SystemClock_Config(void);

 在void rt_hw_board_init(void)函数中添加HAL库初始化和时钟配置的函数,这里使用SysTick定时器为RT-Thread提供心跳,

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

void rt_hw_board_init(void)
{
//#error "TODO 1: OS Tick Configuration."
    /* 
     * TODO 1: OS Tick Configuration
     * Enable the hardware timer and call the rt_os_tick_callback function
     * periodically with the frequency RT_TICK_PER_SECOND. 
     */
    HAL_Init();
    SystemClock_Config();
    SystemCoreClockUpdate();
    
    HAL_SYSTICK_Config(SystemCoreClock / RT_TICK_PER_SECOND);
    
    /* Call components board initial (use INIT_BOARD_EXPORT()) */
#ifdef RT_USING_COMPONENTS_INIT
    rt_components_board_init();
#endif

#if defined(RT_USING_USER_MAIN) && defined(RT_USING_HEAP)
    rt_system_heap_init(rt_heap_begin_get(), rt_heap_end_get());
#endif
}

 添加SysTick系统定时器中断函数,用于操作系统

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

/**
 * This is the timer interrupt service routine.
 *
 */
void SysTick_Handler(void)
{
    /* enter interrupt */
    rt_interrupt_enter();

    HAL_IncTick();
    rt_tick_increase();

    /* leave interrupt */
    rt_interrupt_leave();
}

修改 stm32h7xx_it.c 文件,注释图中的代码STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 HardFault_Handler(void)和MemManage_Handler(void)函数RT-Thread已经实现了,这里注释掉STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

注释系统定时器中断函数,(已经在board.c文件中了)

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32 

打开 rt_config.h 文件,使能信号量、互斥锁、邮箱

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

把main线程的栈改大点

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 

 新建一个 board.h 文件,放到工程目录里,这里面主要是芯片存储有关的内容

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2018-11-5      SummerGift   first version
 */

#ifndef __BOARD_H__
#define __BOARD_H__

#include <rtthread.h>
#include <stm32h7xx.h>
//#include "drv_common.h"
//#include "drv_gpio.h"

#ifdef __cplusplus
extern "C" {
#endif

#define STM32_FLASH_START_ADRESS     ((uint32_t)0x08000000)
#define STM32_FLASH_SIZE             (1024 * 1024)
#define STM32_FLASH_END_ADDRESS      ((uint32_t)(STM32_FLASH_START_ADRESS + STM32_FLASH_SIZE))

#define STM32_SRAM_SIZE           (256) 
#define STM32_SRAM_END            (0x24000000 + STM32_SRAM_SIZE * 1024) /*AXI SRAM, 256KB*/

#if defined(__CC_ARM) || defined(__CLANG_ARM)
extern int Image$$RW_IRAM1$$ZI$$Limit;
#define HEAP_BEGIN      (&Image$$RW_IRAM1$$ZI$$Limit)
#elif __ICCARM__
#pragma section="CSTACK"
#define HEAP_BEGIN      (__segment_end("CSTACK"))
#else
extern int __bss_end;
#define HEAP_BEGIN      (&__bss_end)
#endif

#define HEAP_END        STM32_SRAM_END

void SystemClock_Config(void);

#ifdef __cplusplus
}
#endif

#endif

五、替换sys_arch.c、sys_arch.h、ethernetif.c中有关操作系统的代码

修改 sys_arch.h 文件,如下:

#ifndef __SYS_ARCH_H__
#define __SYS_ARCH_H__

#include "lwip/opt.h"

#include "arch/cc.h"
#include <rtthread.h>

#if (NO_SYS != 0)
#error "NO_SYS need to be set to 0 to use threaded API"
#endif

#ifdef  __cplusplus
extern "C" {
#endif

#ifndef BYTE_ORDER
#define BYTE_ORDER LITTLE_ENDIAN
#endif

#define SYS_MBOX_NULL RT_NULL
#define SYS_SEM_NULL  RT_NULL

//typedef uint32_t sys_prot_t;

#define SYS_MBOX_SIZE 10
#define SYS_LWIP_TIMER_NAME "lwip_timer"
#define SYS_LWIP_MBOX_NAME "lwip_mbox"
#define SYS_LWIP_SEM_NAME "lwip_sem"
#define SYS_LWIP_MUTEX_NAME "lwip_mu"

typedef rt_sem_t sys_sem_t;
typedef rt_mutex_t sys_mutex_t;
typedef rt_mailbox_t  sys_mbox_t;
typedef rt_thread_t sys_thread_t;

#ifdef  __cplusplus
}
#endif

#endif /* __SYS_ARCH_H__ */

修改 sys_arch.c 文件,这个文件里面是有关线程、信号量等的操作,修改成RT-Thread的实现方式:

/* lwIP includes. */
#include "lwip/debug.h"
#include "lwip/def.h"
#include "lwip/sys.h"
#include "lwip/mem.h"
#include "lwip/stats.h"

#if !NO_SYS

#include <rthw.h>
#include <rtthread.h>
#include "sys_arch.h"
/* ====================== Mailbox ====================== */

/*
 * Create an empty mailbox for maximum "size" elements
 *
 * @return the operation status, ERR_OK on OK; others on error
 */
err_t sys_mbox_new(sys_mbox_t *mbox, int size)
{
    static unsigned short counter = 0;
    char tname[RT_NAME_MAX];
    sys_mbox_t tmpmbox;

    RT_DEBUG_NOT_IN_INTERRUPT;

    rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_MBOX_NAME, counter);
    counter ++;

    tmpmbox = rt_mb_create(tname, size, RT_IPC_FLAG_FIFO);
    if (tmpmbox != RT_NULL)
    {
        *mbox = tmpmbox;

        return ERR_OK;
    }

    return ERR_MEM;
}

/*
 * Deallocate a mailbox
 */
void sys_mbox_free(sys_mbox_t *mbox)
{
    RT_DEBUG_NOT_IN_INTERRUPT;

    rt_mb_delete(*mbox);

    return;
}

/** Post a message to an mbox - may not fail
 * -> blocks if full, only used from tasks not from ISR
 * @param mbox mbox to posts the message
 * @param msg message to post (ATTENTION: can be NULL)
 */
void sys_mbox_post(sys_mbox_t *mbox, void *msg)
{
    RT_DEBUG_NOT_IN_INTERRUPT;

    rt_mb_send_wait(*mbox, (rt_uint32_t)msg, RT_WAITING_FOREVER);

    return;
}

/*
 * Try to post the "msg" to the mailbox
 *
 * @return return ERR_OK if the "msg" is posted, ERR_MEM if the mailbox is full
 */
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
{
    if (rt_mb_send(*mbox, (rt_uint32_t)msg) == RT_EOK)
        return ERR_OK;

    return ERR_MEM;
}

err_t
sys_mbox_trypost_fromisr(sys_mbox_t *q, void *msg)
{
  return sys_mbox_trypost(q, msg);
}

/** Wait for a new message to arrive in the mbox
 * @param mbox mbox to get a message from
 * @param msg pointer where the message is stored
 * @param timeout maximum time (in milliseconds) to wait for a message
 * @return time (in milliseconds) waited for a message, may be 0 if not waited
           or SYS_ARCH_TIMEOUT on timeout
 *         The returned time has to be accurate to prevent timer jitter!
 */
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
    rt_err_t ret;
    s32_t t;
    u32_t tick;

    RT_DEBUG_NOT_IN_INTERRUPT;

    /* get the begin tick */
    tick = rt_tick_get();

    if(timeout == 0)
        t = RT_WAITING_FOREVER;
    else
    {
        /* convirt msecond to os tick */
        if (timeout < (1000/RT_TICK_PER_SECOND))
            t = 1;
        else
            t = timeout / (1000/RT_TICK_PER_SECOND);
    }

    ret = rt_mb_recv(*mbox, (rt_ubase_t *)msg, t);
    if(ret != RT_EOK)
    {
        return SYS_ARCH_TIMEOUT;
    }

    /* get elapse msecond */
    tick = rt_tick_get() - tick;

    /* convert tick to msecond */
    tick = tick * (1000 / RT_TICK_PER_SECOND);
    if (tick == 0)
        tick = 1;

    return tick;
}

/** Wait for a new message to arrive in the mbox
 * @param mbox mbox to get a message from
 * @param msg pointer where the message is stored
 * @param timeout maximum time (in milliseconds) to wait for a message
 * @return 0 (milliseconds) if a message has been received
 *         or SYS_MBOX_EMPTY if the mailbox is empty
 */
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
    int ret;

    ret = rt_mb_recv(*mbox, (rt_ubase_t *)msg, 0);

    if(ret == -RT_ETIMEOUT)
        return SYS_ARCH_TIMEOUT;
    else
    {
        if (ret == RT_EOK)
            ret = 1;
    }

    return ret;
}

#ifndef sys_mbox_valid
/** Check if an mbox is valid/allocated:
 *  return 1 for valid, 0 for invalid
 */
int sys_mbox_valid(sys_mbox_t *mbox)
{
    return (int)(*mbox);
}
#endif

#ifndef sys_mbox_set_invalid
/** Set an mbox invalid so that sys_mbox_valid returns 0
 */
void sys_mbox_set_invalid(sys_mbox_t *mbox)
{
    *mbox = RT_NULL;
}
#endif
/*-----------------------------------------------------------------------------------*/
/*
 * Create a new semaphore
 *
 * @return the operation status, ERR_OK on OK; others on error
 */
err_t sys_sem_new(sys_sem_t *sem, u8_t count)
{
    static unsigned short counter = 0;
    char tname[RT_NAME_MAX];
    sys_sem_t tmpsem;

    RT_DEBUG_NOT_IN_INTERRUPT;

    rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_SEM_NAME, counter);
    counter ++;

    tmpsem = rt_sem_create(tname, count, RT_IPC_FLAG_FIFO);
    if (tmpsem == RT_NULL)
        return ERR_MEM;
    else
    {
        *sem = tmpsem;

        return ERR_OK;
    }
}
/*-----------------------------------------------------------------------------------*/
/*
 * Block the thread while waiting for the semaphore to be signaled
 *
 * @return If the timeout argument is non-zero, it will return the number of milliseconds
 *         spent waiting for the semaphore to be signaled; If the semaphore isn't signaled
 *         within the specified time, it will return SYS_ARCH_TIMEOUT; If the thread doesn't
 *         wait for the semaphore, it will return zero
 */
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
{
    rt_err_t ret;
    s32_t t;
    u32_t tick;

    RT_DEBUG_NOT_IN_INTERRUPT;

    /* get the begin tick */
    tick = rt_tick_get();
    if (timeout == 0)
        t = RT_WAITING_FOREVER;
    else
    {
        /* convert msecond to os tick */
        if (timeout < (1000/RT_TICK_PER_SECOND))
            t = 1;
        else
            t = timeout / (1000/RT_TICK_PER_SECOND);
    }

    ret = rt_sem_take(*sem, t);

    if (ret == -RT_ETIMEOUT)
        return SYS_ARCH_TIMEOUT;
    else
    {
        if (ret == RT_EOK)
            ret = 1;
    }

    /* get elapse msecond */
    tick = rt_tick_get() - tick;

    /* convert tick to msecond */
    tick = tick * (1000 / RT_TICK_PER_SECOND);
    if (tick == 0)
        tick = 1;

    return tick;
}

/*
 * Signal a semaphore
 */
void sys_sem_signal(sys_sem_t *sem)
{
    rt_sem_release(*sem);
}

/*
 * Deallocate a semaphore
 */
void sys_sem_free(sys_sem_t *sem)
{
    RT_DEBUG_NOT_IN_INTERRUPT;
    rt_sem_delete(*sem);
}

#ifndef sys_sem_valid
/** Check if a semaphore is valid/allocated:
 *  return 1 for valid, 0 for invalid
 */
int sys_sem_valid(sys_sem_t *sem)
{
    return (int)(*sem);
}
#endif

#ifndef sys_sem_set_invalid
/** Set a semaphore invalid so that sys_sem_valid returns 0
 */
void sys_sem_set_invalid(sys_sem_t *sem)
{
    *sem = RT_NULL;
}
#endif

/* ====================== Mutex ====================== */

/** Create a new mutex
 * @param mutex pointer to the mutex to create
 * @return a new mutex
 */
err_t sys_mutex_new(sys_mutex_t *mutex)
{
    static unsigned short counter = 0;
    char tname[RT_NAME_MAX];
    sys_mutex_t tmpmutex;

    RT_DEBUG_NOT_IN_INTERRUPT;

    rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_MUTEX_NAME, counter);
    counter ++;

    tmpmutex = rt_mutex_create(tname, RT_IPC_FLAG_FIFO);
    if (tmpmutex == RT_NULL)
        return ERR_MEM;
    else
    {
        *mutex = tmpmutex;

        return ERR_OK;
    }
}

/** Lock a mutex
 * @param mutex the mutex to lock
 */
void sys_mutex_lock(sys_mutex_t *mutex)
{
    RT_DEBUG_NOT_IN_INTERRUPT;
    rt_mutex_take(*mutex, RT_WAITING_FOREVER);

    return;
}

/** Unlock a mutex
 * @param mutex the mutex to unlock
 */
void sys_mutex_unlock(sys_mutex_t *mutex)
{
    rt_mutex_release(*mutex);
}

/** Delete a semaphore
 * @param mutex the mutex to delete
 */
void sys_mutex_free(sys_mutex_t *mutex)
{
    RT_DEBUG_NOT_IN_INTERRUPT;

    rt_mutex_delete(*mutex);
}

#ifndef sys_mutex_valid
/** Check if a mutex is valid/allocated:
 *  return 1 for valid, 0 for invalid
 */
int sys_mutex_valid(sys_mutex_t *mutex)
{
    return (int)(*mutex);
}
#endif

#ifndef sys_mutex_set_invalid
/** Set a mutex invalid so that sys_mutex_valid returns 0
 */
void sys_mutex_set_invalid(sys_mutex_t *mutex)
{
    *mutex = RT_NULL;
}
#endif

// Initialize sys arch
void sys_init(void)
{

}

/* ====================== System ====================== */

/*
 * Start a new thread named "name" with priority "prio" that will begin
 * its execution in the function "thread()". The "arg" argument will be
 * passed as an argument to the thread() function
 */
sys_thread_t sys_thread_new(const char    *name,
                            lwip_thread_fn thread,
                            void          *arg,
                            int            stacksize,
                            int            prio)
{
    rt_thread_t t;

    RT_DEBUG_NOT_IN_INTERRUPT;
    
    /* create thread */
    t = rt_thread_create(name, thread, arg, stacksize, prio, 20);
    RT_ASSERT(t != RT_NULL);
    
    /* startup thread */
    rt_thread_startup(t);
    
    return t;
}

sys_prot_t sys_arch_protect(void)
{
    rt_base_t level;

    /* disable interrupt */
    level = rt_hw_interrupt_disable();
    return level;
}

void sys_arch_unprotect(sys_prot_t pval)
{
    /* enable interrupt */
    rt_hw_interrupt_enable(pval);

    return;
}

void sys_arch_assert(const char *file, int line)
{
    rt_kprintf("\nAssertion: %d in %s, thread %s\n",
               line, file, rt_thread_self()->name);
    RT_ASSERT(0);
}

u32_t sys_jiffies(void)
{
    return rt_tick_get();
}

#endif /* !NO_SYS */

将 ethernetif.c 文件中有关信号量、线程等操作的部分,全部改成RT-Thread的实现方式

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32 

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32 

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

在  low_level_output() 函数中添加SCB_CleanInvalidateDCache();

如下图所示:

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

在 low_level_input() 函数中添加 SCB_CleanInvalidateDCache();

如下图所示:

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 修改 lwip.c 文件

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 六、修改 main.c 添加LWIP初始化函数

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

 若使用 AC6编译器,暂时不让 slipif.c 这个文件参与编译

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32

STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细,STM32H723,LWIP,stm32 

 

 完。

注意重点

1.  在  low_level_output()  low_level_input() 函数中添加SCB_CleanInvalidateDCache();

2.  DP83848的PHY地址是在PHYCR(0x19)这个寄存器中,与LAN8742不一样,在LAN8742_Init()函数中改成读取PHYCR(0x19)寄存器。

当然我们也可以在程序手动赋值PHY地址,免去循环读取的步骤。

3.  由于CubeMX只能生成LAN8742的phy代码, 里面涉及到一些扩展寄存器,

一定要修改 LAN8742_GetLinkState(),这个函数是获取当前的以太网链路状态,由于DP83848和LAN8742的扩展寄存器不一样,所以必须修改成DP84848的寄存器(PHYSTS,0x10),不然当网线热插拔时LWIP就会卡死。

凡是涉及到扩展寄存器的,LAN8742和DP83848有所不同,可以自己修改相关的函数。

当网线热插拔时,可以在ethernet_link_status_updated()函数里添加一些自己想要的功能。

4.  LWIP的内存池和内存堆不能放在DTCM中,因为ETH DMA无法访问DTCM。文章来源地址https://www.toymoban.com/news/detail-640376.html

到了这里,关于STM32H723 + DP83848 + LWIP + RT-Thread(FreeRTOS) + STM32CubeMX + Keil MDK 超详细的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 使用RT-Thread Studio搭配STM32CubeMX新建RT-Thread项目

    STM32CubeMX下载 RT-Thread Studio下载 安装好RT-Thread Studio后,先打开RT-Thread SDK管理器确认有没有自己MCU需要的SDK包,直接安装好之后里面是有STM32F1系列的SDK包,其他的需要自己安装。 之后点击文件→新建→RT-Thread项目,根据自己需要配置好后点击完成就会生成RT-Thread项目。 新建项

    2024年02月11日
    浏览(52)
  • 【STM32&RT-Thread零基础入门】8. 基于 CubeMX 移植 RT-Thread Nano

    硬件:STM32F103ZET6、ST-LINK、usb转串口工具、4个LED灯、1个蜂鸣器、4个1k电阻、2个按键、面包板、杜邦线 利用RT_Thread操作系统实现三种不同的LED等闪烁 提示:以下是本篇文章正文内容,下面案例可供参考 cubemx配置参考教程: 基于 CubeMX 移植 RT-Thread Nano 后面程序所需的引脚 RT

    2024年02月09日
    浏览(48)
  • RT-Thread 组件-网络组件-Lwip UDP说明①

    1.1 协议简介 UDP (User Datagram Protocol):用户数据报协议,是一种简单、无连接、不可靠的传输协议。 无需建立连接、没有提供任何流量控制、拥塞控制机制,收到的报文也没有确认,因此 UDP 的传输速度快,但不能保证数据到达目的地。 与我们熟知的 TCP 协议一样,都属于 OS

    2024年02月22日
    浏览(43)
  • 【STM32&RT-Thread零基础入门】 4. 线程介绍(理论)

    前文中的最后一个任务发现,一个main()函数很难同时实现按键功能和闪灯功能,就好像人很难同时完成左手画圆右手画方一样,这种情况可以安排一人去画圆、一人去画方,并行进行就很容易了,两人各司其职,互不干扰。 操作系统中,一个线程就像做事的一个人。一个操作

    2024年02月12日
    浏览(41)
  • RT-Thread:STM32实时时钟 RTC开启及应用

    说明: STM32F103/407系列基于 RT-Thread 系统的 RTC 开启及应用 应用流程介绍。 完成以上系统配置,编译无误情况下RTC 就已经开启了。 官方 API 查询地址:https://www.rt-thread.org/document/api/rtc_sample_8c-example.html#a3 1.设置日期:设置系统日期但不修改时间 2.设置时间:设置系统时间但不

    2024年01月17日
    浏览(63)
  • STM32CubeMX+VSCODE+EIDE+RT-THREAD 工程创建

            Eide环境搭建暂且不表,后续补充。主要记录下Vscode环境下 创建Rt-thread工程的过程。分别介绍STM32CubeMX添加rtt支持包的方式和手动添加rtt kernel方式。STM32CubeMX生成工程的时候有\\\"坑\\\",防止下次忘记,方便渡一下有缘人,特此记录。         此工程以创建stm32f405为例

    2024年02月14日
    浏览(51)
  • RT-Thread STM32 GoKit V2.1 开发板BSP说明

    本文档为刘恒为 GoKit V2.1 开发板提供的 BSP (板级支持包) 说明。 主要内容如下: 开发板资源介绍 BSP 快速上手 进阶使用方法 通过阅读快速上手章节开发者可以快速地上手该 BSP,将 RT-Thread 运行在开发板上。在进阶使用指南章节,将会介绍更多高级功能,帮助开发者利用 RT-

    2024年02月04日
    浏览(42)
  • RT-Thread Studio配置LAN8720+LWIP+TCP服务器实现

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 由于项目上需要使用RT-Thread建立TCP服务器实现与客户端的数据交互,查阅了不少资料以及踩了不少坑,这里记录和分享一下实现的过程,希望能帮助到有需要的同学,您的支持是我创作的最大动力,谢谢

    2024年01月25日
    浏览(47)
  • RT-Thread在STM32硬件I2C的踩坑记录

    参考文章: 1.将硬件I2C巧妙地将“嫁接”到RTT原生的模拟I2C驱动框架 2.基于STM32F4平台的硬件I2C驱动实现笔记 3.《rt-thread驱动框架分析》- i2c驱动   最近打算用RT-Thread做一个小demo玩玩,其中需要用I2C通信驱动一个oled屏幕,但是找了一圈也没找到RTT中对硬件I2C的支持方式以及

    2024年02月11日
    浏览(74)
  • 【STM32&RT-Thread零基础入门】 7. 线程创建应用(多线程运行机制)

    硬件:STM32F103ZET6、ST-LINK、usb转串口工具、4个LED灯、1个蜂鸣器、4个1k电阻、2个按键、面包板、杜邦线 本章进一步研究多线程的运行机制。要求实现功能如下:创建2个线程,线程名称分别为LED和BEEP。两个线程的任务是连续5次打印本线程的名字后退出线程(注意:线程不执行

    2024年02月03日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包