11、STM32H7 MPU Cache

已于 2023-04-19 10:01:35 修改
阅读量1.3k 收藏 24
点赞数 4
分类专栏： STM32 文章标签： stm32 单片机 嵌入式硬件
于 2023-04-19 09:52:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36561846/article/details/130229211
版权

篇前小问题

在使用stm32H750的FMC时，出现一些奇怪的问题，写A时序时时，总是写1次的代码了出现了写四次的时序，所以找了很久，才找到问题出在了MPU上，使用FMC时，必须开启MPU，不然会出现此现象。
在这里插入图片描述
while一直执行该函数，会出现此时序图：
在这里插入图片描述
读时序是两字节，但是写出现的时序明显异常
经过解决，才出现正常的时序，如下所示
在这里插入图片描述
解决方法：
开启FMC的区域保护：

void MPU_Config(void)
{
  MPU_Region_InitTypeDef MPU_InitStruct = {0};

  /* Disables the MPU */
  HAL_MPU_Disable();
  /** Initializes and configures the Region and the memory to be protected
  */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER0;
  MPU_InitStruct.BaseAddress = 0x60000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
  MPU_InitStruct.SubRegionDisable = 0x0;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;

  HAL_MPU_ConfigRegion(&MPU_InitStruct);
  /* Enables the MPU */
  HAL_MPU_Enable(MPU_HFNMI_PRIVDEF);

}

同样问题经验贴参考：https://www.stmcu.org.cn/module/forum/forum.php?mod=viewthread&tid=623865&page=1#pid2491693
至于为什么非要开启MPU呢，因为
在这里插入图片描述
参考出处：https://www.armbbs.cn/forum.php?mod=viewthread&tid=89929
说了这么多，先发下代码吧：
在这里插入图片描述
在这里插入图片描述
fmc.c

/**
  ******************************************************************************
  * File Name          : FMC.c
  * Description        : This file provides code for the configuration
  *                      of the FMC peripheral.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "fmc.h"

/* USER CODE BEGIN 0 */
/* USER CODE END 0 */

SRAM_HandleTypeDef hsram1;

/* FMC initialization function */
void MX_FMC_Init(void)
{
  /* USER CODE BEGIN FMC_Init 0 */
  /* USER CODE END FMC_Init 0 */

  FMC_NORSRAM_TimingTypeDef Timing = {0};
  FMC_NORSRAM_TimingTypeDef ExtTiming = {0};

  /* USER CODE BEGIN FMC_Init 1 */
  /* USER CODE END FMC_Init 1 */

  /** Perform the SRAM1 memory initialization sequence
  */
  hsram1.Instance = FMC_NORSRAM_DEVICE;
  hsram1.Extended = FMC_NORSRAM_EXTENDED_DEVICE;
  /* hsram1.Init */
  hsram1.Init.NSBank = FMC_NORSRAM_BANK1;
  hsram1.Init.DataAddressMux = FMC_DATA_ADDRESS_MUX_DISABLE;
  hsram1.Init.MemoryType = FMC_MEMORY_TYPE_SRAM;
  hsram1.Init.MemoryDataWidth = FMC_NORSRAM_MEM_BUS_WIDTH_16;
  hsram1.Init.BurstAccessMode = FMC_BURST_ACCESS_MODE_DISABLE;
  hsram1.Init.WaitSignalPolarity = FMC_WAIT_SIGNAL_POLARITY_LOW;
  hsram1.Init.WaitSignalActive = FMC_WAIT_TIMING_BEFORE_WS;
  hsram1.Init.WriteOperation = FMC_WRITE_OPERATION_ENABLE;
  hsram1.Init.WaitSignal = FMC_WAIT_SIGNAL_DISABLE;
  hsram1.Init.ExtendedMode = FMC_EXTENDED_MODE_ENABLE;
  hsram1.Init.AsynchronousWait = FMC_ASYNCHRONOUS_WAIT_DISABLE;
  hsram1.Init.WriteBurst = FMC_WRITE_BURST_DISABLE;
  hsram1.Init.ContinuousClock = FMC_CONTINUOUS_CLOCK_SYNC_ONLY;
  hsram1.Init.WriteFifo = FMC_WRITE_FIFO_DISABLE;
  hsram1.Init.PageSize = FMC_PAGE_SIZE_NONE;
  /* Timing */
  Timing.AddressSetupTime = 15;
  Timing.AddressHoldTime = 15;
  Timing.DataSetupTime = 255;
  Timing.BusTurnAroundDuration = 15;
  Timing.CLKDivision = 16;
  Timing.DataLatency = 17;
  Timing.AccessMode = FMC_ACCESS_MODE_A;
  /* ExtTiming */
  ExtTiming.AddressSetupTime = 15;
  ExtTiming.AddressHoldTime = 15;
  ExtTiming.DataSetupTime = 255;
  ExtTiming.BusTurnAroundDuration = 15;
  ExtTiming.CLKDivision = 16;
  ExtTiming.DataLatency = 17;
  ExtTiming.AccessMode = FMC_ACCESS_MODE_A;

  if (HAL_SRAM_Init(&hsram1, &Timing, &ExtTiming) != HAL_OK)
  {
    Error_Handler( );
  }

  /* USER CODE BEGIN FMC_Init 2 */
  /* USER CODE END FMC_Init 2 */
}

static uint32_t FMC_Initialized = 0;

static void HAL_FMC_MspInit(void){
  /* USER CODE BEGIN FMC_MspInit 0 */
  /* USER CODE END FMC_MspInit 0 */
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if (FMC_Initialized) {
    return;
  }
  FMC_Initialized = 1;
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};

  /** Initializes the peripherals clock
  */
    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_FMC;
    PeriphClkInitStruct.PLL2.PLL2M = 8;
    PeriphClkInitStruct.PLL2.PLL2N = 20;
    PeriphClkInitStruct.PLL2.PLL2P = 2;
    PeriphClkInitStruct.PLL2.PLL2Q = 2;
    PeriphClkInitStruct.PLL2.PLL2R = 2;
    PeriphClkInitStruct.PLL2.PLL2RGE = RCC_PLL2VCIRANGE_3;
    PeriphClkInitStruct.PLL2.PLL2VCOSEL = RCC_PLL2VCOMEDIUM;
    PeriphClkInitStruct.FmcClockSelection = RCC_FMCCLKSOURCE_PLL2;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
    {
      Error_Handler();
    }

  /* Peripheral clock enable */
  __HAL_RCC_FMC_CLK_ENABLE();

  /** FMC GPIO Configuration
  PE7   ------> FMC_D4
  PE8   ------> FMC_D5
  PE9   ------> FMC_D6
  PE10   ------> FMC_D7
  PE11   ------> FMC_D8
  PE12   ------> FMC_D9
  PE13   ------> FMC_D10
  PE14   ------> FMC_D11
  PE15   ------> FMC_D12
  PD8   ------> FMC_D13
  PD9   ------> FMC_D14
  PD10   ------> FMC_D15
  PD13   ------> FMC_A18
  PD14   ------> FMC_D0
  PD15   ------> FMC_D1
  PC7   ------> FMC_NE1
  PD0   ------> FMC_D2
  PD1   ------> FMC_D3
  PD4   ------> FMC_NOE
  PD5   ------> FMC_NWE
  */
  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
                          |GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14
                          |GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_13
                          |GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_0|GPIO_PIN_1
                          |GPIO_PIN_4|GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF9_FMC;

  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /* USER CODE BEGIN FMC_MspInit 1 */
  /* USER CODE END FMC_MspInit 1 */
}

void HAL_SRAM_MspInit(SRAM_HandleTypeDef* sramHandle){
  /* USER CODE BEGIN SRAM_MspInit 0 */
  /* USER CODE END SRAM_MspInit 0 */
  HAL_FMC_MspInit();
  /* USER CODE BEGIN SRAM_MspInit 1 */
  /* USER CODE END SRAM_MspInit 1 */
}

static uint32_t FMC_DeInitialized = 0;

static void HAL_FMC_MspDeInit(void){
  /* USER CODE BEGIN FMC_MspDeInit 0 */
  /* USER CODE END FMC_MspDeInit 0 */
  if (FMC_DeInitialized) {
    return;
  }
  FMC_DeInitialized = 1;
  /* Peripheral clock enable */
  __HAL_RCC_FMC_CLK_DISABLE();

  /** FMC GPIO Configuration
  PE7   ------> FMC_D4
  PE8   ------> FMC_D5
  PE9   ------> FMC_D6
  PE10   ------> FMC_D7
  PE11   ------> FMC_D8
  PE12   ------> FMC_D9
  PE13   ------> FMC_D10
  PE14   ------> FMC_D11
  PE15   ------> FMC_D12
  PD8   ------> FMC_D13
  PD9   ------> FMC_D14
  PD10   ------> FMC_D15
  PD13   ------> FMC_A18
  PD14   ------> FMC_D0
  PD15   ------> FMC_D1
  PC7   ------> FMC_NE1
  PD0   ------> FMC_D2
  PD1   ------> FMC_D3
  PD4   ------> FMC_NOE
  PD5   ------> FMC_NWE
  */

  HAL_GPIO_DeInit(GPIOE, GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
                          |GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14
                          |GPIO_PIN_15);

  HAL_GPIO_DeInit(GPIOD, GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_13
                          |GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_0|GPIO_PIN_1
                          |GPIO_PIN_4|GPIO_PIN_5);

  HAL_GPIO_DeInit(GPIOC, GPIO_PIN_7);

  /* USER CODE BEGIN FMC_MspDeInit 1 */
  /* USER CODE END FMC_MspDeInit 1 */
}

void HAL_SRAM_MspDeInit(SRAM_HandleTypeDef* sramHandle){
  /* USER CODE BEGIN SRAM_MspDeInit 0 */
  /* USER CODE END SRAM_MspDeInit 0 */
  HAL_FMC_MspDeInit();
  /* USER CODE BEGIN SRAM_MspDeInit 1 */
  /* USER CODE END SRAM_MspDeInit 1 */
}
/**
  * @}
  */

/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "fatfs.h"
#include "sdmmc.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"
#include "fmc.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "Common_Driver.h"
#include "sdCheck.h"
#include "Key_Driver.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MPU_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
typedef struct
{
  volatile uint16_t LCD_REG;
  volatile uint16_t LCD_RAM;
} LCD_TypeDef;

#define LCD_BASE        ((uint32_t)(0x60000000 | 0x0007FFFE))
#define LCD ((LCD_TypeDef *) LCD_BASE)

void TestSRAM(void)
{
  volatile uint16_t x = 0;

  x = LCD->LCD_REG;
  x = LCD->LCD_RAM;
  LCD->LCD_REG = 0x00;
  LCD->LCD_RAM = 0x00;
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
  extern uint8_t KeyFlag[2];
  /* USER CODE END 1 */

  /* MPU Configuration--------------------------------------------------------*/
  MPU_Config();

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */
  //MPU_Configx();
  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_SDMMC1_SD_Init();
  MX_FATFS_Init();
  MX_TIM17_Init();
  MX_FMC_Init();
  /* USER CODE BEGIN 2 */
  sdCheck_Init();
  Key_Init();
  //HAL_TIM_Base_Start_IT(&htim17);//1ms任务,需在服务器之前启动
  HAL_Delay(1);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
    TestSRAM();
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Supply configuration update enable
  */
  HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
  /** Configure the main internal regulator output voltage
  */
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);

  while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
  /** Macro to configure the PLL clock source
  */
  __HAL_RCC_PLL_PLLSOURCE_CONFIG(RCC_PLLSOURCE_HSI);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_DIV1;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 4;
  RCC_OscInitStruct.PLL.PLLN = 60;
  RCC_OscInitStruct.PLL.PLLP = 2;
  RCC_OscInitStruct.PLL.PLLQ = 20;
  RCC_OscInitStruct.PLL.PLLR = 2;
  RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3;
  RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
  RCC_OscInitStruct.PLL.PLLFRACN = 0;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
                              |RCC_CLOCKTYPE_D3PCLK1|RCC_CLOCKTYPE_D1PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
  RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/* MPU Configuration */

void MPU_Config(void)
{
  MPU_Region_InitTypeDef MPU_InitStruct = {0};

  /* Disables the MPU */
  HAL_MPU_Disable();
  /** Initializes and configures the Region and the memory to be protected
  */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER0;
  MPU_InitStruct.BaseAddress = 0x60000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
  MPU_InitStruct.SubRegionDisable = 0x0;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;

  HAL_MPU_ConfigRegion(&MPU_InitStruct);
  /* Enables the MPU */
  HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);

}

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  printf("Error:Error_Handler()\n");
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

正篇

MPU（内存保护单元）：简单的说就是内存保护、外设保护和代码访问保护
MPU可以保护16个内存区域（独立配置），每个区域最小256字节，每个区域还可以配置为 8 个子区域。由于子区域一般都相同大小，这样每个子区域的大小就是 32 字节，正好跟 Cache 的 Cache Line 大小一样。MPU 可以配置的 16 个内存区的序号范围是 0 到 15，还有默认区 default region，也叫作背景区，序号-1。

MPU的三种内存类型：

在这里插入图片描述

MPU寄存器

寄存器MPU_RASR
在这里插入图片描述
控制寄存器CTRL
在这里插入图片描述
HAL库使用MPU时常用的3个函数：

void HAL_MPU_Disable(void)
void HAL_MPU_Enable(uint32_t MPU_Control)
void HAL_MPU_ConfigRegion(MPU_Region_InitTypeDef *MPU_Init)
1、void HAL_MPU_Enable(uint32_t MPU_Control)

此函数用于使能 MPU，一般情况使用参数 MPU_PRIVILEGED_DEFAULT。
在这里插入图片描述

2、void HAL_MPU_ConfigRegion(MPU_Region_InitTypeDef *MPU_Init)
/** @defgroup CORTEX_MPU_Region_Initialization_Structure_definition MPU Region Initialization Structure Definition
  * @brief  MPU Region initialization structure
  * @{
  */
typedef struct
{
  uint8_t                Enable;                /*!< Specifies the status of the region.
                                                     This parameter can be a value of @ref CORTEX_MPU_Region_Enable                 */
  uint8_t                Number;                /*!< Specifies the number of the region to protect.
                                                     This parameter can be a value of @ref CORTEX_MPU_Region_Number                 */
  uint32_t               BaseAddress;           /*!< Specifies the base address of the region to protect.                           */
  uint8_t                Size;                  /*!< Specifies the size of the region to protect.
                                                     This parameter can be a value of @ref CORTEX_MPU_Region_Size                   */
  uint8_t                SubRegionDisable;      /*!< Specifies the number of the subregion protection to disable.
                                                     This parameter must be a number between Min_Data = 0x00 and Max_Data = 0xFF    */
  uint8_t                TypeExtField;          /*!< Specifies the TEX field level.
                                                     This parameter can be a value of @ref CORTEX_MPU_TEX_Levels                    */
  uint8_t                AccessPermission;      /*!< Specifies the region access permission type.
                                                     This parameter can be a value of @ref CORTEX_MPU_Region_Permission_Attributes  */
  uint8_t                DisableExec;           /*!< Specifies the instruction access status.
                                                     This parameter can be a value of @ref CORTEX_MPU_Instruction_Access            */
  uint8_t                IsShareable;           /*!< Specifies the shareability status of the protected region.
                                                     This parameter can be a value of @ref CORTEX_MPU_Access_Shareable              */
  uint8_t                IsCacheable;           /*!< Specifies the cacheable status of the region protected.
                                                     This parameter can be a value of @ref CORTEX_MPU_Access_Cacheable              */
  uint8_t                IsBufferable;          /*!< Specifies the bufferable status of the protected region.
                                                     This parameter can be a value of @ref CORTEX_MPU_Access_Bufferable             */
}MPU_Region_InitTypeDef;

示例配置：

MPU_Region_InitTypeDef MPU_InitStruct;

/* 禁止 MPU */
HAL_MPU_Disable();

/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
MPU_InitStruct.BaseAddress      = 0x24000000;
MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
MPU_InitSruct.IsBufferable      = MPU_ACCESS_BUFFERABLE;
MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
MPU_InitStruct.SubRegionDisable = 0x00;
MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;

HAL_MPU_ConfigRegion(&MPU_InitStruct);

/*使能 MPU */
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);

Number参数：设定当前配置的保护区域编号。此处配置的是0号区域。一共16个区域，0-15
MPU总共有16个可以独立配置的内存保护区域（在CM4内核的MCU中是8个），范围从015。对应的参数就是MPU_REGION_NUMBER0到MPU_REGION_NUMBER15。注意，这些区域编号顺序和其保护的内存区域的顺序无关。也就是说，完全可以配置1号区域为0x240000000x24080000，而2号区域用来保护0x00000000~0x00010000。
MPU保护的区域可以重叠。在发生重叠的时候，优先应用高序号的MPU配置。也就是，序号更大的MPU区域优先级更高。
除了0~15这16个保护区域外，还有一个编号为-1的内存保护区域，其称之为默认区域（default region)或背景区域（background region）。其优先级为最低。默认区域的访问策略由启用MPU的函数HAL_MPU_Enable的参数指定。

Enable参数：此参数用来决定此区域的MPU配置是否启用。

/** @defgroup CORTEX_MPU_Region_Enable CORTEX MPU Region Enable
  * @{
  */
#define  MPU_REGION_ENABLE     ((uint8_t)0x01)
#define  MPU_REGION_DISABLE    ((uint8_t)0x00)

BaseAddress参数、Size参数：此参数用来确定内存保护区域的具体范围
这两个参数在一起确定了内存区域的范围。其中BaseAddress是保护区域的起始地址。Size则是区域的大小。内存区域的起始地址必须对齐到设定的大小。比如将Size设定为1M，那么BaseAddress就必去对齐到1M。即 BaseAddress % Size == 0 。此外，Size是不能随意设置的，只能从 MPU_REGION_SIZE_xxx的宏中进行选取
AccessPermission参数：配置此区域的内存访问（读写）权限
在这里插入图片描述
SubRegionDisable参数
这个位用于控制内存区的子区域，使用的是 bit[15:8]，共计 8 个 bit，一个 bit 控制一个子区域，0表示使能此子区域，1 表示禁止此子区域。一般情况，基本不使用子区域的禁止功能，所以配置 HAL 库的 SubRegionDisable 参数时，直接取值 0x00 即可，表示 8 个子区域均使能。
DisableExec参数：这个参数用来控制当前区域中的指令（代码）是否可以执行
XN=0 表示使能指令提取，即这块内存区可以执行程序代码，XN=1 表示禁止指令提取，即这块内存区禁止执行程序代码。

/** @defgroup CORTEX_MPU_Instruction_Access CORTEX MPU Instruction Access
  * @{
  */
#define  MPU_INSTRUCTION_ACCESS_ENABLE      ((uint8_t)0x00)
#define  MPU_INSTRUCTION_ACCESS_DISABLE     ((uint8_t)0x01)

IsBufferable、IsCacheable、IsShareable、TypeExtField参数：这几个参数组合起来共同决定了所配置的内存区域的缓存和共享策略

 MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
 MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
 MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;

在这里插入图片描述
S位用于解决多总线或者多核访问的共享问题，一般不要开启；
TEX = 000表示读开辟，RA； TEX= 001表示读写开辟RWA;
C表示缓存使能标志–cacheable，1表示使能；
B表示bufferable，1表示回写，0表示透写。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

四种Cache（ MPU） 配置的读写操作流

注意，M7 内核只要开启了 Cache，read allocate 就是开启的。

1、配置 Non-cacheable

就是正常的读写操作，无 Cache。
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
此处可以看看另一篇文章的解释https://blog.csdn.net/qq_28242041/article/details/129582995，方便理解上面为什么说读写错误
在这里插入图片描述
在这里插入图片描述

透写和回写缓存（Write Through and Write Back in Cache）

透写和回写缓存
高速缓存（Cache）是一种将数据副本临时存储在可快速访问的存储内存中的技术。缓存将最近使用的数据存储在小内存中，以提高访问数据的速度。它充当 RAM 和 CPU 之间的缓冲区，从而提高处理器可用数据的速度。每当处理器想要写入一个字时，它都会检查它想要写入数据的地址是否存在于缓存中。如果地址存在于缓存中，即写入命中（Write Hit）。我们可以更新缓存中的值并避免昂贵的主内存访问。但这会导致数据不一致（Inconsistent Data）问题。由于高速缓存和主存都有不同的数据，如在多处理器系统中，这将导致两个或多个共享主存的设备出现问题。这就是透写（Write Through）和回写（Write Back）出现的地方。

透写（Write Through）
在透写（Write Through）场景中，数据同时更新到缓存和内存（simultaneously updated to cache and memory）。这个过程更简单、更可靠。这用于没有频繁写入缓存的情况（写入操作的次数较少）。

它有助于数据恢复（在断电或系统故障的情况下）。因为我们必须写入两个位置（内存和缓存），数据写入将经历延迟。虽然它解决了不一致的问题，但它的问题是在写操作中使用缓存的优势，因为使用缓存的全部目的是避免对主内存的多次访问。
在这里插入图片描述

回写（Write Back）
回写（Write Back）也被称为延迟写入（Write Behind / Write Deferred）。也就是说，最初数据只在缓存中更新，稍后再更新到内存中。对内存的写入动作会被推迟，直到修改的内容在缓存中即将被另一个缓存块替换。
在这里插入图片描述
变脏标志位（Dirty Bit）：缓存中的每个块都需要一个位来指示缓存中存在的数据是被修改（变脏的）还是未被修改（干净的）。如果它是干净的，则无需将其写入内存。它旨在减少对内存的写操作。如果缓存发生故障（Cache fails）或系统发生故障（System fails）或断电（Power outages），修改后的数据将丢失。因为如果数据丢失了，几乎不可能从缓存中恢复数据。
支持回写的缓存实现起来比较复杂，因为它需要跟踪哪些位置已被覆盖，并将它们标记为变脏，以便稍后写入后备内存中。只有当这些位置的数据从缓存中被逐出时，它们才会被写回后备内存中，这种效果称为延迟写入。出于这个原因，回写缓存中的读取未命中（需要一个块被另一个块替换）通常需要两次内存访问来服务：一次将替换的数据从缓存写回存储，然后一次检索所需的数据。
其他策略也可能触发数据回写。如客户端可能对缓存中的数据进行了多次更改，然后显式通知缓存写回数据。

回写（Write Back）通常与写分配（Write Allocation）一起使用。因为这样不需要将数据从内存中带入缓存，然后再把数据更新缓存和主内存中。同时希望后续写入（甚至读取）到现在已缓存的同一位置。
透写（Write Through）通常与无写分配（No Write Allocate）一起使用。因为它们仍然需要直接写入后备内存，所以在这里后续写入没有优势。

STM32H7内存默认映射和属性

在这里插入图片描述
WT 表示 Write-through（透写）
WB 表示 Write-back（回写）
WA 表示 Write-allocate（写分配）
没有明确标注 WA 的就是 RA（读分配）
XN 的意思是 Execute-Never， 其含义为如果相应的地址空间是 XN，是绝不允许执行代码的。
存储器类型为 Normal 的才能使用 cache，并且 TCM 接口是 not cacheable 的。

MPU不配行不行？
在大多数的情况下，如果不访问外部存储空间（如LCD，Flash等），不开启cache的情况下，不配MPU不会有什么问题。但是：
1、H7关闭cache后，性能会有大幅度的下降。
2、由于H7的定位，我们也基本不可能不使用外部存储器。而访问外部存储的内存空间时，如果不配置MPU，则会出现很多奇怪的BUG。比如笔者遇到的FMC

文档参考：

透写和回写缓存（Write Through and Write Back in Cache）：https://zhuanlan.zhihu.com/p/571429282
STM32H7/M7中的MPU（内存保护单元）配置详解：https://oshwhub.com/article/STM32H7-M7zhong-de-MPU-nei-cun-bao-hu-dan-yuan-pei-zhi-yang-xie
https://blog.csdn.net/qq_28242041/article/details/129582995
使用STM32H7的FMC注意MPU配置：https://www.armbbs.cn/forum.php?mod=viewthread&tid=89929
STM32H750使用FMC控制LCD数据异常：https://www.stmcu.org.cn/module/forum/forum.php?mod=viewthread&tid=623865&page=1#pid2491693

@残梦
关注
  • 4
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32H7系列MCU的MPU和Cache功能介绍
weixin_51029119的博客
07-14 2034
Cache 又分数据缓存 D-Cache 和指令缓冲 I-Cache，STM32H7 的数据缓存和指令缓存大小都是 16KB。STM32H7 最高主频是 480MHz，除了 TCM 和 Cache 以 480MHz 工作，其它 AXI SRAM，SRAM1，SRAM2 等都是以 240MHz 工作。数据缓存 D-Cache 就是解决 CPU 加速访问 SRAM。
STM32H7的Cache和MPU
hitman_cs的博客
03-11 7584
STM32H7的Cache和MPU_qlexcel的专栏-CSDN博客 例说STM32F7高速缓存——Cache一致性问题（一）_人人都懂物联网-CSDN博客 转！！！ 关于cache的原理和使用，看着两篇文章就够了！！
STM32H7---高速缓存Cache(一)
热门推荐
Z小旋
03-22 1万+
引言： 在使用STM32H7 跟F7系列芯片的时候经常看到第一句初始化就是 Cache_Enable(); //打开L1-Cache //使能CPU的L1-Cache void Cache_Enable(void) { SCB_EnableICache();//使能I-Cache SCB_EnableDCache();//使能D-Cache SCB->CACR|=1<<2; //强制D-Cache透写,如不开启,实际使用中可能遇到
STM32中的ICACHE是什么有什么用？如何使用？
最新发布
小超电子笔记
05-10 684
icache是一种用于缓存指令的存储器，其目的是提高CPU执行指令的效率。在计算机系统中，icache（指令缓存）是处理器核心内部的一个关键组件，它专门用来存储最近使用过的指令。当CPU需要执行一个指令时，会首先检查i-cache中是否已经缓存了该指令。如果所需的指令已在i-cache中（这种情况称为缓存命中），CPU可以直接从i-cache中快速读取指令，无需等待从主内存中获取，这显著提高了指令的访问速度并提升了程序的执行效率。
STM32H743+DMA+UART+CACHE
12-20
1.解决了Cache数据不一致的问题 2.实现了基于STM32H743+DMA+UART的通信 3.采用串口的空闲中断，可接收发送任意数据长度
STM32【H7】理论——MPU、Cache
Adam's Rib for Antennnin
05-26 4416
MPU 可以配置的 16 个内存区的序号范围是 0 到 15,还有默认区 default region,也叫作背景区,序号-1；由于这些内存区可以嵌套和重叠,所以这些区域在嵌套或者重叠时有个优先级的问题。序号15 的优先级最高,以此递减,序号-1,即背景区的优先级最低。：MPU 可以独立配置保护 16 个内存区域，每个区域最小要求 256 字节，每个区域还可以配置为 8 个子区域；由于子区域一般都大小相同，这样每个子区域的大小就是 32 字节，正好跟 Cache 的 Cache Line 大小一样；
STM32H7-MPU的理解和配置
Monster_Kee
03-26 7924
STM32H7-MPU 一、MPU的作用 防止不受信用的应用程序访问受保护的内存区域 防止用户应用程序破坏操作系统使用的数据 通过阻止任务访问其他任务的数据区 允许将内存区域定义为只读，以便保护重要数据。 检测意外的内存访问 简单来说，就是内存保护、外设保护和代码访问保护。 二、MPU的功能实现 ​ MPU可以配置保护16个内存区域，每个区域都是独立配置的。每个区域的最小要求是32字节，同时每个区域还可以配置为8个子区域，通过寄存器对应的bit来使能。 ​ MPU可配置的16个内存区的序号范围是0-15
STM32 MPU（内存保护单元）F7、H7
lanzh_syf的博客
04-15 1579
MPU，即内存保护单元，可以设置不同存储区域的存储器访问特性（如只支持特权访问或全访问）和存储器属性（如可缓存、可缓冲、可共享），对存储器（主要是内存和外设）提供保护，从而提高系统可靠性：1，阻止用户应用程序破坏操作系统使用的数据。2，阻止一个任务访问其他任务的数据区，从而隔离任务。3，可以把关键数据区域设置为只读，从根本上解决被破坏的可能。4，检测意外的存储访问，如堆栈溢出，数组越界等。5，将 SRAM 或者 RAM 空间定义为不可执行（用不执行， XN），防止代码注入攻击。
STM32H750+MPU+CACHE
08-28
文件"MPUCACHE"可能是教程的源代码示例或者配置文件，供读者下载并参考，以加深对MPU和CACHE在STM32H750应用中的理解和实践。 总之，STM32H750结合MPU和CACHE技术，可以实现高效、安全的嵌入式系统设计。利用STM32...
STM32F7 MPU Cache浅析中文.zip
08-12
关于STM32的教程PDF免费分享给大家，电子设计大赛相关的资源。 如果您觉得这些免费资源对您有帮助的话，我会非常感谢您的支持，您可以考虑给我点赞或关注，这将是对我分享内容的一种鼓励，也会让我更有动力继续分享...
STM32HAL库MPU6050
04-04
STM32HAL库MPU6050是一个项目，它结合了STMicroelectronics的STM32微控制器的高性能HAL库，用于与InvenSense公司的MPU6050六轴陀螺仪和加速度计进行通信。这个项目适用于在CLion集成开发环境中进行开发，并通过虚拟...
基于stm32的mpu6050陀螺仪控制舵机
01-15
基于stm32的mpu6050陀螺仪控制舵机。。。基于stm32的mpu6050陀螺仪控制舵机。。。基于stm32的mpu6050陀螺仪控制舵机。。。基于stm32的mpu6050陀螺仪控制舵机。。。基于stm32的mpu6050陀螺仪控制舵机。。。基于stm32...
stm32+mpu9250程序
05-30
STM32L053与MPU9250结合使用的程序主要涉及到嵌入式系统、传感器技术以及微控制器编程等多个知识点。以下是这些关键领域的详细解释： 1. **STM32L053**：STM32L053是意法半导体（STMicroelectronics）推出的一款...
STM32_H7
三皮仔
08-06 5234
STM32H7的Cache和MPU STM32H7的FMC总线应用之SDRAM
STM32H723、STM32H743、STM32H750的区别
小灰灰的博客
08-23 9659
例如，STM32H723提供高达2 MB的闪存和564 KB的RAM，STM32H743提供高达2 MB的闪存和1 MB的RAM，而STM32H750提供高达1 MB的闪存和340 KB的RAM。STM32H723的最大频率为550 MHz，STM32H743的最大频率为480 MHz，而STM32H750的最大频率为480 MHz。例如，STM32H723和STM32H743都可提供LQFP、UFBGA、BGA和WLCSP等多种封装选项，而STM32H750主要提供LQFP封装。
番外篇：STM32H7的Cache和MPU以及内存分配问题
weixin_44584198的博客
07-21 6773
一、Cache 1、介绍 Cache又分数据缓存D-Cache和指令缓冲I-Cache，STM32H7的数据缓存和指令缓存大小都是16KB。STM32H7主频是400MHz，除了TCM和Cache以400MHz工作，其它AXI SRAM，SRAM1，SRAM2等都是以200MHz工作。数据缓存D-Cache就是解决CPU加速访问SRAM。 如果每次CPU要读写SRAM区的数据，都能够在Cache里面进行，自然是最好的，实现了200MHz到400MHz的飞跃，实际是做不到的，因为数据Cache只有16KB大小
使用cubemx配置stm32h4750vb的mpu
weixin_66689383的博客
07-29 1352
超级详细的stm32cubemx配置mpu
STM32 MPU内存保护单元
Notebook
03-16 1559
先说明一下MPU，MPU有很多含义，我们常见的有：MPU：Memory Protection Unit，内存保护单元（本文描述的内容）；MPU：Microprocessor Unit，微处理器；MPU-6050 陀螺仪 跟这个就更是差了十万八千里了所以请不要搞混MPU，即内存保护单元，可以设置不同存储区域的存储器访问特性（如只支持特权访问或全访问）和存储器属性（如可缓存、可缓冲、可共享），对存储器（主要是内存和外设）提供保护，从而提高系统可靠性通过这些规则可以实现如下功能也就是内存保护、外设保护和代码访问保
STM32硬件IIC 主从（一、CubeMx快速实现）
qq_36561846的博客
06-02 1万+
目的 通过HAL库实现STM32F103C8T6两块板之间的IIC主从相互通信，串口打印接收数据。 环境搭建 /**I2C1 GPIO Configuration PB6 ------> I2C1_SCL PB7 ------> I2C1_SDA 注意通信线记得接上拉电阻4.7k。 CubeMx配置 配置sys 串行调试 配置外部高速时钟 配置串口，默认值 配置IIC，默认值，从机地址0x01,左移1位=0x02 开启IIC的事件中断与错误中断 代码 1
stm32h7 mpu
09-22
STM32H7 MPU（Memory Protection Unit）是一种用于STM32H7系列芯片的内存保护单元。它的作用是保护内存区域，防止非法访问或错误操作。MPU可以配置最多16个独立的内存保护区域，每个区域最小要求256字节，并且可以配置为8个子区域。每个子区域的大小是32字节，与Cache Line大小相同。通过MPU的配置，可以实现对STM32H7芯片中的各种硬件资源的保护和安全控制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值