STM32L051测试 (四、Flash和EEPROM的读写)

723 阅读16分钟

本文已参与「新人创作礼」活动,一起开启掘金创作之路。

本 STM32L051测试系列文章目录:

STM32L051测试 (一、使用CubeMX生成工程文件 — ST系列芯片通用)

STM32L051测试 (二、开始添加需要的代码)

STM32L051测试 (三、I2C协议设备的添加测试)

本文测试L051 flash的读写

1、STM32L051内部存储模块地址范围

开始找到F103的FLASH图复习了一遍,然后L051C8T6,64KB的flash, 然后我惊奇的发现还有2KB的EEPROM。

发现L051系列的地址与F103完全不同,F103的flash每页的长度有1KB(小容量<=64KB)和2KB(大容量128KB起)查看各种资料,

查了2个小时,还是不知道L051的flash 每页长度是 128Byte 还256Byte????????

还是请教了一下大佬,发现直接在J-Flash中可以找到答案,先上个F103的图:

在这里插入图片描述

然后来看个L051的图:

在这里插入图片描述

图中64KB 的flash 和2KB的EEPROM都能都明显的看出地址,flash 512页,每页128bytes,EEPROM只有4页,每页512bytes.知道了基本的地址,就可以操作起来了。

最后还需要确定的一点事,最小擦除单元是128bytes,还是256bytes,按以前的认知,删除是按照一个Sector擦除的,也就是128bytes,但是我查看了一些网上的例子和资料,有的是说256bytes,所以后面需要自己确定一下

其实在HAL库的 stm32l0xx_hal_flash.h 文件中有过 FLASH_PAGE_SIZE 的定义,就是128bytes :

#define FLASH_SIZE                (uint32_t)((*((uint32_t *)FLASHSIZE_BASE)&0xFFFF) * 1024U)
#define FLASH_PAGE_SIZE           ((uint32_t)128U)  /*!< FLASH Page Size in bytes */

对于flash的操作,有一些基础知识补充一下:

Read interface organized by word, half-word or byte in every area
• Programming in the Flash memory performed by word or half-page
• Programming in the Option bytes area performed by word
• Programming in the data EEPROM performed by word, half-word or byteErase operation performed by page (in Flash memory, data EEPROM and Option
bytes)

STM32L051写Flash必须字,读 字节、半字、字都支持。(这句话也是错误的,这是以前哪里看到的,实际测试写可以根据字,半字,字节来写)

一些基本概念:

定义字是根据处理器的特性决定的。
首先ARM是32bit处理器,所以它的字是32bit的。半字自然就是16bit;
字节不论在哪个CPU上都是8bit。
1 Byte = 8 bits(即 1B=8b)
1 KB = 1024 Bytes
Bit意为“位”或“比特”,是计算机运算的基础,属于二进制的范畴;
Byte意为“字节”,是计算机文件大小的基本计算单位;

2、读写函数的设计

HAL库中肯定是有对flash和EEPROM进行操作的函数,我们这里新建一个stml0_flash.c 和stml0_flash.h 函数分别放在对应位置,进行自己的函数设计。

库中Flash与EEPROM的函数看样子是分别放在stm32l0xx_hal_flash.c 和 stm32l0xx_hal_flash_ex.c 中的,我们先使用EEPROM,因为提供EEPROM,就是让用户可以保存一些掉电后的数据的嘛,测试完EEPROM,再去测试下flash,因为怕有时候数据不够放……

2.1 读取函数

//读取指定地址的半字(16位数据)
uint16_t FLASH_ReadHalfWord(uint32_t address)
{
  return *(__IO uint16_t*)address; 
}

//读取指定地址的全字(32位数据)
uint32_t FLASH_ReadWord(uint32_t address)
{
  return *(__IO uint32_t*)address;
}

简单测试一下:

u32 read_data1=0XFFFFFFFF;
u32 read_data2=0XFFFFFFFF;
...
read_data1 = FLASH_ReadWord(DATA_EEPROM_START_ADDR);
printf("the DATA_EEPROM_START_ADDR is: 0x %x \r\n",read_data1);
read_data2 = FLASH_ReadWord(DATA_EEPROM_START_ADDR + EEPROM_PAGE_SIZE);
printf("the EEPROM sceond page test data is: 0x %x \r\n",read_data2);

没有写入数据读取的值应该都是0。

2.2 EEPROM写函数

对EEPROM的写函数: stm32l0xx_hal_flash_ex.h中函数如下:

HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Unlock(void);
HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Lock(void);

HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address);
HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data);

通过函数看来,可以直接用,但是这里有一个问题

需要测试一下,擦除是否会擦除整个扇区,有待验证!!

答:EEPROM的擦除可以直接擦除某个地址的字,不会擦除整个片区

EEPROM的操作相对Flash,比较简单,直接使用HAL库中的函数即可完成

HAL_FLASHEx_DATAEEPROM_Unlock();
HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, DATA_EEPROM_START_ADDR, write_data1);
HAL_FLASHEx_DATAEEPROM_Lock();
...
if(btn_getState(&K1_BUTTON_150mS) == BTN_EDGE2){
        printf(" K1 150ms button!,EEPROM_Erase test\r\n");
        HAL_FLASHEx_DATAEEPROM_Unlock();
        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_START_ADDR+4);
        HAL_FLASHEx_DATAEEPROM_Lock();
        HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
    }
...
if(btn_getState(&K2_BUTTON_150mS) == BTN_EDGE2){
        printf(" K2 150ms button!EEPROM_read test\r\n");
        read_data1 = FLASH_ReadWord(DATA_EEPROM_START_ADDR);
        printf("the DATA_EEPROM_START_ADDR is: 0x %x \r\n",read_data1);
    }

按照上面的例子,擦除DATA_EEPROM_START_ADDR+4的地址不会影响DATA_EEPROM_START_ADDR地址的开始写入的数据写入一样,如果不在意以前的数据,直接写入就可以。

总结来说EEPROM的使用还是很好用而且简单的。

而且EEPROM是可以按照字节,半字,全字写入的,测试了一下,是右对齐

右对齐什么意思呢,打个比方就是如果在地址 addr 中,本来写入全字 0x12345678 然后直接在EEPROM 的 addr 这个地址,写入半字 0xFFFF, 再读取全字的话,addr 地址的全字就变成了 0x1234FFFF ,这个具体的为什么在地址写入半字,不会直接从地址开始占用2个字节,是因为地址的类型为 uint32_t ,所以该地址就是 4个字节类型的数。

写入问题说明修改

修改说明 上面一段的解释有误,这里修改一下,不是因为地址类型为uint32_t,地址类型永远是这个,是因为定义的数据类型为uint32_t ,然后STM32又是小端模式,所以保存的方式是从地址的最后开始保存,4个字节的全字,第一个字节放在地址开始+4 的位置,第二个字节放在地址开始+3的位置,所以如果调用HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, DATA_EEPROM_START_ADDR, write_data1);

关键在于FLASH_TYPEPROGRAMDATA_WORD以全字方式写入半字,那么内核会自动分配4个字节的宽度,半字的第一个字节放在写入地址+4 的位置,第二个字节放在写入地址+3的位置,所以导致了上面的结果

  HAL_FLASHEx_DATAEEPROM_Unlock();
  HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, DATA_EEPROM_START_ADDR, 0X88);
  HAL_FLASHEx_DATAEEPROM_Lock();
  read_data1 = FLASH_ReadWord(DATA_EEPROM_START_ADDR);
  printf("the DATA_EEPROM_START_ADDR is: 0x %x \r\n",read_data1);

最后在 stml0_flash.h 中把函数完善声明一下,使得主函数中的程序更加简洁。

void MY_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)   
{
	HAL_FLASHEx_DATAEEPROM_Unlock(); 			 		 
    HAL_FLASHEx_DATAEEPROM_Program(TypeProgram, Address, Data);
	HAL_FLASHEx_DATAEEPROM_Lock();
} 

那么L051 的EEPROM的测试就到这里,其实有EEPROM,在项目中的保存数据的功能就问题不大了,但是我们既然开始了,就把L051 Flash的读写也测试一下。

2.3 Flash写函数

Flash的读取其实和EEPROM一样,主要是写函数,来看一下stm32l0xx_hal_flash.h 中有哪些函数

/* IO operation functions *****************************************************/
HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data);
HAL_StatusTypeDef HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint32_t Data);

/* FLASH IRQ handler function */
void       HAL_FLASH_IRQHandler(void);
/* Callbacks in non blocking modes */
void       HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue);
void       HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue);

/**
  * @}
  */

/** @addtogroup FLASH_Exported_Functions_Group2
  * @{
  */
/* Peripheral Control functions ***********************************************/
HAL_StatusTypeDef HAL_FLASH_Unlock(void);
HAL_StatusTypeDef HAL_FLASH_Lock(void);
HAL_StatusTypeDef HAL_FLASH_OB_Unlock(void);
HAL_StatusTypeDef HAL_FLASH_OB_Lock(void);
HAL_StatusTypeDef HAL_FLASH_OB_Launch(void);

有点忙,Flash的后面再也,看了几个demo,只需要做几个测试就可以;

2021.8.5 今天有空来接着测试一下L051 Flash的读写,看了下HAL_FLASH_Program函数:

HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)
{
  HAL_StatusTypeDef status = HAL_ERROR;
  
  /* Process Locked */
  __HAL_LOCK(&pFlash);

  /* Check the parameters */
  assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
  assert_param(IS_FLASH_PROGRAM_ADDRESS(Address));

  /* Wait for last operation to be completed */
  status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
  
  if(status == HAL_OK)
  {
    /* Clean the error context */
    pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;

    /*Program word (32-bit) at a specified address.*/
    *(__IO uint32_t *)Address = Data;

    /* Wait for last operation to be completed */
    status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
  }

  /* Process Unlocked */
  __HAL_UNLOCK(&pFlash);

  return status;
}

这里也再次说明了,L051的写必须以字的方式写入。

不管了,先测试一下,不擦除直接写入,这里先定义一下写入的地址,前面我们已经知道了L051 flash一共 512页,每页128bytes,所以我们直接拿最后面的几页来测试

#define ADDR_FLASH_PAGE_505      0X08000000 + 128*504   //
#define ADDR_FLASH_PAGE_506      0X08000000 + 128*505   //
#define ADDR_FLASH_PAGE_507      0X08000000 + 128*506   //
#define ADDR_FLASH_PAGE_508      0X08000000 + 128*507   //
#define ADDR_FLASH_PAGE_509      0X08000000 + 128*508   //
#define ADDR_FLASH_PAGE_510      0X08000000 + 128*509   //
#define ADDR_FLASH_PAGE_511      0X08000000 + 128*510   //
#define ADDR_FLASH_PAGE_512      0X08000000 + 128*511   //最后一页

开始先不擦除,直接在最后一页写入一个字读取一下试试,整理一下写入函数:

void MY_DATAFLASH_Program(uint32_t Address, uint32_t Data)   
{
	HAL_FLASH_Unlock(); 			 		 
  if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, Data) == HAL_OK){
    printf("write data 0x%x OK\n", Data);
  }
  else{
    printf("failed!!!\n");
  }
	HAL_FLASH_Lock();
} 

测试一下;

  MY_DATAFLASH_Program(ADDR_FLASH_PAGE_512,write_data2);
  read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_512);
  printf("the ADDR_FLASH_PAGE_512 is: 0x %x \r\n",read_data1);

在没有写入flash之前,该地址读出来的数据为0,写入后读出来是正常写入的数据 这里有个疑问,按理来说,flash存储器有个特点,就是只能写0,不能写1,所以flash的写入,比需先擦除,或者至少检查一下该数据区是否可以写入,但是L051 怎么初始的时候读出来是0? 难道L051的有区别,需要测试一下

先在一个地址写0XFFFFFFFF ,然后写完了再写一次别的数据看看能否直接写入,结果是写入了0XFFFFFFFF ,不能继续直接写数据,说明,估计L051是相反的,这里具体是不是我只看测试结果,结论的话我自己知道就可以应用,希望有权威大神指正。

这里我们得用到一个关键的函数 ,这个函数是在stm32l0xx_hal_flash_ex.c 这个文件中的,是flash的擦除函数: HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError)

所以这里我们知道了以后,可以优化一下写入函数,我们项目中用到的是可以直接对某个地址的写入,然后也不需要保存,此页其他的数据,所以我们把函数改成如下:

void MY_DATAFLASH_Program(uint32_t Address, uint32_t Data)   
{
  FLASH_EraseInitTypeDef EraseInitStruct;
  uint32_t checkdata;
  uint32_t PAGEError = 0;
  checkdata = FLASH_ReadWord(Address);
	HAL_FLASH_Unlock(); 
  /*如果是0,直接写*/
  if(checkdata == 0){			 		 
    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, Data) == HAL_OK){
      printf("write data 0x%x OK\n", Data);
    }
    else{
      printf("failed!!!\n");
    }
  }
  /*否则擦除再写*/
  else{
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR);

      EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;	// 刷除方式
	  EraseInitStruct.PageAddress = Address;	// 起始地址
      EraseInitStruct.NbPages = 1;

      if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
      {
        // 如果刷除错误
        printf("\r\n FLASH Erase Fail\r\n");
        printf("Fail Code:%d\r\n",HAL_FLASH_GetError());
        printf("Fail Page:%d\r\n",PAGEError);
      }

      if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, Data) == HAL_OK){
      printf("write data 0x%x OK\n", Data);
      }
      else{
        printf("failed!!!\n");
      }

  }
	HAL_FLASH_Lock();
} 

自己修改了一个函数, 改成这样以后,就能直接在想写入的地方写入数据了,到这里,flash足够我项目中的使用了。但是还有最后一个疑问,就是擦除的一页到底是不是128bytes我来验证一下。

u32 write_data1 = 0X12345678;
u32 write_data2 = 0X87654321;
u32 write_data3 = 0XFFFFFFFF;

MY_DATAFLASH_Program(ADDR_FLASH_PAGE_508 + 124,0X508508FF);
MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509,write_data3);
MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509+4,write_data2);
MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509+8,write_data1);
MY_DATAFLASH_Program(ADDR_FLASH_PAGE_510,0X510510FF); 

read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_508 + 124);
 printf("the ADDR_FLASH_PAGE_508 last is: 0x %x \r\n",read_data1);
  read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509);
  printf("the ADDR_FLASH_PAGE_509 1 is: 0x %x \r\n",read_data1);
  read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 4);
  printf("the ADDR_FLASH_PAGE_509 2 is: 0x %x \r\n",read_data1);
  read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 8);
  printf("the ADDR_FLASH_PAGE_509 3 is: 0x %x \r\n",read_data1);
  read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_510);
  printf("the ADDR_FLASH_PAGE_510 first is: 0x %x \r\n",read_data1);

if(btn_getState(&K2_BUTTON_150mS) == BTN_EDGE2){
        printf(" K2 150ms button!EEPROM_read test\r\n");
        read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_508 + 124);
        printf("the ADDR_FLASH_PAGE_508 last is: 0x %x \r\n",read_data1);
        read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509);
        printf("the ADDR_FLASH_PAGE_509 1 is: 0x %x \r\n",read_data1);
        read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 4);
        printf("the ADDR_FLASH_PAGE_509 2 is: 0x %x \r\n",read_data1);
        read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 8);
        printf("the ADDR_FLASH_PAGE_509 3 is: 0x %x \r\n",read_data1);
        read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_510);
        printf("the ADDR_FLASH_PAGE_510 first is: 0x %x \r\n",read_data1);

    }
if(btn_getState(&K1_BUTTON_150mS) == BTN_EDGE2){
        // printf(" K1 150ms button!,EEPROM_Erase test\r\n");
        // MY_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, DATA_EEPROM_START_ADDR, write_data1);
        printf(" K1 150ms button!,flash write test\r\n");
        MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509,0X33333333);
        HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
    }

因为地址位置如果有数据的话会擦除一页再写入,所以我们看了一下508页最后一个地址,和510页的第一个地址数据,对509页的数据进行了操作,结果发现不会改变508 和510的数据,509页的数据会全部清除!

在这里插入图片描述

在这里插入图片描述

所以得出的结论显而易见,flash擦除按照一页一页擦除, 在L051上面一页为128bytes,而且擦除后数据全部为 0;

2.4 读写EEPROM的后续问题

最近有一个项目,因为缺货 STM32L051R系列缺货,买了 STM32L071RBT6 替代:

在这里插入图片描述

看了一下地址,其实我们上面所有的测试代码基本都是可以直接用的,代码直接用STM32L051的代码也是可以的,实际项目中,还是使用EEPROM比较方便,所以在使用EEPROM的时候,发现了一个问题(并不是换了芯片的问题),还是数据读取和写入的问题。

2.4.1 问题的出现和解决

下面程序的硬件平台是 STM32L071RBT6,首先在程序中,有一个写ID的函数:

在这里插入图片描述

写入IO是通过字节的方式 byte 写入的,写了6个字节(蓝牙设备的ID)。

然后最初读取的函数用的是:

在这里插入图片描述

使用这个读ID的函数,问题就出来了。

上图代码中,我读取ID使用的是半字读取,处理方式是把读到的半字前面8位给ID1, 后面8位给ID2, 但是测试中发现 数据读出来与想要的相反,什么意思呢,看下面的测试说明:

上电打印出EEPROM中读取的一个地址的,每个ID(每个ID是uint8_t类型)的数据,在代码开始定义了测试数据:

BlueID_STRUCT test;
...
/*
CHBlueID_STRUCT Flash_PowerOn_BlueCheck()
{

	CHBlueID_STRUCT PowerOn_ID;
	PowerOn_ID.CH1ID = FLASH_blueIDRead(CH1_ID_ADDR);
	PowerOn_ID.CH2ID = FLASH_blueIDRead(CH2_ID_ADDR);
	PowerOn_ID.CH3ID = FLASH_blueIDRead(CH3_ID_ADDR);
	PowerOn_ID.CH4ID = FLASH_blueIDRead(CH4_ID_ADDR);
	PowerOn_ID.CH5ID = FLASH_blueIDRead(CH5_ID_ADDR);
	PowerOn_ID.CH6ID = FLASH_blueIDRead(CH6_ID_ADDR);
	PowerOn_ID.CH7ID = FLASH_blueIDRead(CH7_ID_ADDR);
	PowerOn_ID.CH8ID = FLASH_blueIDRead(CH8_ID_ADDR);
	PowerOn_ID.CH9ID = FLASH_blueIDRead(CH9_ID_ADDR);
	PowerOn_ID.CH10ID = FLASH_blueIDRead(CH10_ID_ADDR);

	return PowerOn_ID;
}
*/
BlueChipID = Flash_PowerOn_BlueCheck(); //上电先把ID读出来做比较
//打印一个出来测试,看结果
printf("BlueChipID.CH1ID is 0x%x,0x%x,0x%x,0x%x,0x%x,0x%x\r\n",BlueChipID.CH1ID.ID1,BlueChipID.CH1ID.ID2,BlueChipID.CH1ID.ID3,BlueChipID.CH1ID.ID4,BlueChipID.CH1ID.ID5,BlueChipID.CH1ID.ID6);

test.ID1= 0XFF; //结构体每个元素是 uint8_t 类型
test.ID2= 0XEE;
test.ID3= 0XDD;
test.ID4= 0XCC;
test.ID5= 0XBB;
test.ID6= 0XAA;

while (1){...}

在程序中通过操作,写入测试数据,调用上面提到过的写ID的函数,写ID的函数是每个字节每个字节写的:

在这里插入图片描述

按我们希望的结果来说,读出来按照顺序打印,应该是:0xff,0xee,0xdd,0xcc,0xbb,0xaa 。测试实际上是:

在这里插入图片描述

为了确实是读的问题还是写的问题,添加了读字节的函数:

在这里插入图片描述

在这里插入图片描述

打印的结果:

在这里插入图片描述

说明确实是ID的读取函数出的问题,是因为使用的半字读取,问题处理不麻烦,我们把读取函数修改一下:

BlueID_STRUCT FLASH_blueIDRead(uint32_t address)
{
	BlueID_STRUCT u48id;
  // uint16_t temp1,temp2,temp3;  /**(__IO uint16_t*)address; */
  // temp1=*(__IO uint16_t*)address; 
	// u48id.ID1 = (uint8_t)(temp1>>8);
	// u48id.ID2 = (uint8_t)(temp1&0X00FF);
  // temp2=*(__IO uint16_t*)(address+2);
	// u48id.ID3 = (uint8_t)(temp2>>8);
	// u48id.ID4 = (uint8_t)(temp2&0X00FF);
	// temp3=*(__IO uint16_t*)(address+4);
	// u48id.ID5 = (uint8_t)(temp3>>8);
	// u48id.ID6 = (uint8_t)(temp3&0X00FF); 

  u48id.ID1 =  FLASH_Readbyte(address);
  u48id.ID2 =  FLASH_Readbyte(address+1);
  u48id.ID3 =  FLASH_Readbyte(address+2);
  u48id.ID4 =  FLASH_Readbyte(address+3);
  u48id.ID5 =  FLASH_Readbyte(address+4);
  u48id.ID6 =  FLASH_Readbyte(address+5);

  return u48id;
}

测试结果才正常了,如下图:

在这里插入图片描述

2.4.2 问题的分析(大小端模式数据格式)

出现上面的问题,其实是和我们经常说的大端模式和小端模式有关的。

STM32使用的是小端模式,简单介绍一下大端模式小端模式数据存放的方式,如下图:

在这里插入图片描述

知道上面的知识,我们在开始的读取函数中是直接读取的半字(__IO uint16_t*)address; ,但是我们写入的时候是一个字节一个字节写入,上面的例子所以我们内存中的数据实际上如下图所示:

在这里插入图片描述

使用(__IO uint16_t*)address; 去读取,读取出来的数值一个uint16_t类型的数值:

假设是 a,a=*(__IO uint16_t*)addr; 会有 a = 0xEEFF; 所以高8位变成了 0xEE。 OK! 解释清楚!问题解决!

至此,我们基本上把STM32L051 的EEPROM 和Flash 功能都测试过了,把工程中需要用到的功能做了测试,也学到了一些新的知识,还是实践出结论啊,当初没有自己测试之前看了网上的有关类似的介绍,还是很多误解,这下全部清晰了。

2.4.3 STM32L071RBT6 EEPROM读写全字问题

读问题的出现

前面其实测试过,读取全字是可以的,直接使用return *(__IO uint32_t*)address;:便可以读到该地址的全字:

uint32_t  FLASH_ReadWord(uint32_t address)
{
  return *(__IO uint32_t*)address;
}

所以在后面使用过程中,有这么一个函数:

在这里插入图片描述

一开始还真的不知道哪里出了问题?折腾了好一阵才发现调用函数读取ID时就会卡死。

问题的解决:

因为还有另外一个蓝牙版本的产品,如果是蓝牙设备的ID,因为蓝牙设备的ID是6位的,所以当时读取蓝牙的ID的时候使用的是(蓝牙版本是没问题的):

在这里插入图片描述

其实折腾了好一会儿,后来想着蓝牙是读一个字节,要不要试着把 全字 分为 4个字节,单独读取试一试?

于是学蓝牙把程序分为4个字节读取:

在这里插入图片描述

代码也放一下,方便复制:

u32 FLASH_ReadEnoceanID(uint32_t address)
{
  u32 keepid;
  u8 i;
  keepid = FLASH_Readbyte(address);
  i = FLASH_Readbyte(address + 1);
  keepid = (i<<8)|keepid;
  i = FLASH_Readbyte(address + 2);
  keepid = (i<<16)|keepid;
  i = FLASH_Readbyte(address + 3);
  keepid = (i<<24)|keepid;
  return keepid;
}

CHID_STRUCT Flash_PowerOn_Check()
{

	CHID_STRUCT PowerOn_ID;
	PowerOn_ID.CH1ID = FLASH_ReadEnoceanID(CH1_ID_ADDR);
	PowerOn_ID.CH2ID = FLASH_ReadEnoceanID(CH2_ID_ADDR);
	PowerOn_ID.CH3ID = FLASH_ReadEnoceanID(CH3_ID_ADDR);
	PowerOn_ID.CH4ID = FLASH_ReadEnoceanID(CH4_ID_ADDR);
	PowerOn_ID.CH5ID = FLASH_ReadEnoceanID(CH5_ID_ADDR);
	PowerOn_ID.CH6ID = FLASH_ReadEnoceanID(CH6_ID_ADDR);
	PowerOn_ID.CH7ID = FLASH_ReadEnoceanID(CH7_ID_ADDR);
	PowerOn_ID.CH8ID = FLASH_ReadEnoceanID(CH8_ID_ADDR);
	PowerOn_ID.CH9ID = FLASH_ReadEnoceanID(CH9_ID_ADDR);
	PowerOn_ID.CH10ID = FLASH_ReadEnoceanID(CH10_ID_ADDR);

	return PowerOn_ID;
}

测试一下,发现就好了,至于原因,目前还不知道为什么……(最后问题解决有说明,内存字节对齐问题)

写问题的出现

本来以为解决了上面问题OK了,可是后面测试的时候发现写的时候也有问题:

一直用的写全字函数为:

FLASH_Status  FLASH_WriteWord(uint32_t Address, uint32_t Data)
{

	FLASH_Status i = FLASH_COMPLETE;

	HAL_FLASHEx_DATAEEPROM_Unlock(); 	
  while(HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, Address, Data) != HAL_OK);
	HAL_FLASHEx_DATAEEPROM_Lock();

	return i;
}

在程序中会调用此函数进行 ID 保存:

在这里插入图片描述

但是使用时候发现:

在这里插入图片描述

问题的解决:

其实这个问题也莫名其妙,真是说不出来为什么,估计是得详细的查看数据手册,但是还是 因为 在蓝牙的版本上面没有此类问题:

在这里插入图片描述

所以这里还是尝试改成 以 字节 方式写入:

FLASH_Status  FLASH_WriteWord(uint32_t Address, uint32_t Data)
{

  FLASH_Status state = FLASH_COMPLETE;
  u8 i = 0;
  u8 writedata[6]={0};

  writedata[0] = (u8)Data;
  writedata[1] = (u8)(Data>>8);
  writedata[2] = (u8)(Data>>16);
  writedata[3] = (u8)(Data>>24);

	HAL_FLASHEx_DATAEEPROM_Unlock(); 	
  for(i=0; i<4; i++){
    while(HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, Address + i, writedata[i]) != HAL_OK);
  }
	HAL_FLASHEx_DATAEEPROM_Lock();

	return state;
}

使用此种方式写入,就不会出现问题!

其实也可以尝试修改地址,使得成为 4 的倍数,可能也不会出问题,这里就不测试了(最后问题解决有还是测试了,内存字节对齐问题)

2.4.3小结使用的芯片为 STM32L071RBT6

最后问题的解决

先直接说结论,就是EEPROM地址定义的问题,应该是4字节对齐(4的整数倍),读取全字的操作才能正常!

上面 STM32L071RBT6 EEPROM 读写全字问题的关键在于,存储地址的定义上,如上面一张图所示: (我在EEPROM区域定义了10个地址,用来存放无线设备的ID数据,如果是蓝牙芯片,那么ID为6个字节,如果是Enocean芯片,那么ID为4个字节,为了保持代码的统一,我在使用保存4个字节的ID数据的地址定义时候沿用的是蓝牙的 EEPROM区域定义)

在这里插入图片描述

那么正如我图中猜想的一样,蓝牙的 ID 6个字节,我是都是通过一个字节一个字节操作,组合起来进行的,所以一切正常。 但是对于 4个字节的 ID ,期初是用的 全字的方式,就出问题了,换成一个字节一个字节的操作,看上去是解决问题了。

但是实际上多了一些隐藏问题,暂时也说不清楚,在产品使用的时候,读写ID还是会有莫名其妙的问题,最终还是对当初的这个猜想,地址是不是也需要4字节对齐?进行了修改测试,于是乎,对于 4 个字节 ID的处理,地址改成:

在这里插入图片描述

把地址修改成 4 的倍数以后,上面的读取全字的两个函数便可以正常使用,而不会出上面莫名其妙的问题。

总结

在STM32L0 系列读取 EEPROM 的时候,需要注意:

字节操作,传入合理范围内的任何地址参数都可以;

半字操作,地址需要 2 字节对齐,就是 2的倍数;

全字操作,地址需要 4 字节对齐,就是 4 的倍数;