【LPC55s69】使用FAL分区管理与easyflash变量管理

以放

本博文作为我本人在移植RT-Thread软件spi框架成功后所提供的配套应用测试开发文档，文中部分测试用例已上传RT-Thread仓库，而目前LPC55s69系列与RT-Thread的对接已完善大部分，欢迎大家测试。

1.FAL组件
1.1什么是FAL

FAL (Flash Abstraction Layer) Flash 抽象层，是对 Flash 及基于 Flash 的分区进行管理、操作的抽象层，对上层统一了 Flash 及 分区操作的 API (框架图如下所示)，并具有以下特性：

• 支持静态可配置的分区表，并可关联多个 Flash 设备；
• 分区表支持 自动装载 。避免在多固件项目，分区表被多次定义的问题；
• 代码精简，对操作系统 无依赖 ，可运行于裸机平台，比如对资源有一定要求的 Bootloader；
• 统一的操作接口。保证了文件系统、OTA、NVM（例如：EasyFlash） 等对 Flash 有一定依赖的组件，底层 Flash 驱动的可重用性；
• 自带基于 Finsh/MSH 的测试命令，可以通过 Shell 按字节寻址的方式操作（读写擦） Flash 或分区，方便开发者进行调试、测试；
  
  

通过上图我们也可以清晰明了看到，FAL抽象层向下可以通过Flash硬件进行统一管理，当然也可以使用SFUD框架（串行Flash通用驱动库，这部分RT-Thread官方已完成框架的移植同时提供多个应用历程），而对上也可以使用如DFS、NVM提供的Flash硬件统一访问接口，方便用户更加直接方便对底层flash硬件的访问操作。

注：非易失性存储器 (NVM)：在芯片电源关闭期间保存存储在其中的数据。 因此，它被用于没有磁盘的便携式设备中的内存，以及用于可移动存储卡等用途。 主要类型有：非易失性半导体存储器 (Non-volatile semiconductor memory, NVSM) 将数据存储在浮栅存储单元中，每个单元都由一个浮栅(floating-gate) MOSFET 组成。

关于存储，可以用一张图来解释：

来源：ROM、RAM、FLASH、NVM……一文搞定

1.2 使用ENV配置FAL

在RT-Thread v4.1.0之前，FAL是作为软件包形式对用户开放使用的，而v4.1.0之后，FAL被RT-Thread官方重新定义为RTT组件的一部分，这样也能更加方便用户的开发。

我们下面正式讲解FAL组件的使用：

首先打开ENV工具，根据以下路径打开FAL使能RT-Thread Components->FAL: flash abstraction layer，由于我们后面会用到SFUD，所以这里把FAL uses SFUD drivers一并使能，并修改FAL设备名称为W25Q128.

完成上述操作后保存退出，并使用scons --target=mdk5重新生成MDK5文件并打开

1.3 FAL SFUD 移植

为了提供示例，我们选用W25Q128 spi flash作为测试模块，并且使用SFUD框架对spi flash设备进行管理和驱动。

由于目前RT-Thread的SFUD已经对W25Q128完成支持，根据官方的使用手册，我们仅需编写fal_cfg.h文件完成对FAL_FLASH_DEV_TABLE及FAL_PART_TABLE的定义即可。文件存放路径：.\rt-thread\bsp\lpc55sxx\lpc55s69_nxp_evk\board\ports\fal_cfg.h

1. // fal.cfg.h
   
2. ​
   
3. /*
   
4.   * Copyright (c) 2006-2023, RT-Thread Development Team
   
5.   *
   
6.   * SPDX-License-Identifier: Apache-2.0
   
7.   *
   
8.   * Change Logs:
   
9.   * Date           Author       Notes
   
10.   * 2023-04-21     Wangyuqiang  the first version
    
11.   */
    
12. #ifndef _FAL_CFG_H_
    
13. #define _FAL_CFG_H_
    
14. ​
    
15. #include <rtthread.h>
    
16. #include <board.h>
    
17. ​
    
18. #ifndef FAL_USING_NOR_FLASH_DEV_NAME
    
19. #define NOR_FLASH_DEV_NAME             "norflash0"
    
20. #else
    
21. #define NOR_FLASH_DEV_NAME              FAL_USING_NOR_FLASH_DEV_NAME
    
22. #endif
    
23. ​
    
24. /* Flash device Configuration */
    
25. ​
    
26. extern struct fal_flash_dev nor_flash0;
    
27. ​
    
28. /* flash device table */
    
29. ​
    
30. #define FAL_FLASH_DEV_TABLE                                          \
    
31. {                                                                    \
    
32.      &nor_flash0,                                                     \
    
33. }
    
34. ​
    
35. /* Partition Configuration */
    
36. ​
    
37. #ifdef FAL_PART_HAS_TABLE_CFG
    
38. ​
    
39. /* partition table */
    
40. ​
    
41. #define FAL_PART_TABLE                                                                                                  \
    
42. {                                                                                                                       \
    
43.      {FAL_PART_MAGIC_WROD,  "easyflash", NOR_FLASH_DEV_NAME,                                    0,       512 * 1024, 0}, \
    
44.      {FAL_PART_MAGIC_WROD,   "download", NOR_FLASH_DEV_NAME,                           512 * 1024,      1024 * 1024, 0}, \
    
45.      {FAL_PART_MAGIC_WROD, "wifi_image", NOR_FLASH_DEV_NAME,                  (512 + 1024) * 1024,       512 * 1024, 0}, \
    
46.      {FAL_PART_MAGIC_WROD,       "font", NOR_FLASH_DEV_NAME,            (512 + 1024 + 512) * 1024,  7 * 1024 * 1024, 0}, \
    
47.      {FAL_PART_MAGIC_WROD, "filesystem", NOR_FLASH_DEV_NAME, (512 + 1024 + 512 + 7 * 1024) * 1024,  7 * 1024 * 1024, 0}, \
    
48. }
    
49. #endif /* FAL_PART_HAS_TABLE_CFG */
    
50. ​
    
51. #endif /* _FAL_CFG_H_ */

复制代码

此时编译的话是找不到该头文件的，需要我们在Keil中设置：

在RTT FAL组件中的SFUD提供的fal_flash_dev对象默认的nor_flash0参数中，flash大小默认为8M，而W25Q128最大最16M，我们可以选择在.\rt-thread\components\fal\samples\porting\fal_flash_sfud_port.c文件中对struct fal_flash_dev nor_flash0进行修改：

1. struct fal_flash_dev nor_flash0 =
   
2. {
   
3.      .name       = FAL_USING_NOR_FLASH_DEV_NAME,
   
4.      .addr       = 0,
   
5.      .len        = 16 * 1024 * 1024,
   
6.      .blk_size   = 4096,
   
7.      .ops        = {init, read, write, erase},
   
8.      .write_gran = 1
   
9. };

复制代码

当然也可以选择不进行修改，根据大佬的原话就是因为在调用初始化接口函数init后，会从flash设备读取正确的参数更新到nor_flash0表项中，我们在使用FAL组件前都需要调用FAL初始化函数fal_init，其内调用flash设备初始化函数fal_flash_init，最后会调用注册到fal_flash_dev设备表项中的初始化函数device_table->ops.init，所以nor_flash0表项参数会在FAL初始化时被更新。

同时我们需要开启SFUD框架支持，打开ENV工具，由于SFUD的使用需要指定一个spi设备，这里我选择使用最近移植好的软件spi，路径Hardware Drivers Config->On-chip Peripheral Drivers-> Enable soft SPI BUS-> Enable soft SPI1 BUS (software simulation)，这里我的测试开发板是恩智浦的LPC55S69-EVK，并且这款bsp的软件模拟spi由我本人对接，关于这部分的软件spi引脚定义可以选用默认即可，当然也可以使用自定义引脚，记住不要与其他引脚产生冲突。

此时我们回到ENV主界面，进入RT-Thread Components->Device Drivers->Using Serial Flash Universal Driver，此时我们才可以看到SFUD选项出现（如果没有使能spi是没法看到的），使能后保持默认即可

到这里，ENV的配置暂时告一段落！

1.4 FAL SFUD 测试用例

为了验证W25Q128及软件模拟spi在SFUD框架上是否能够成功运行，我们在.\rt-thread\bsp\lpc55sxx\lpc55s69_nxp_evk\board\ports\下新建一个soft_spi_flash_init.c文件，代码如下

1. /*
   
2.   * Copyright (c) 2006-2023, RT-Thread Development Team
   
3.   *
   
4.   * SPDX-License-Identifier: Apache-2.0
   
5.   *
   
6.   * Change Logs:
   
7.   * Date           Author       Notes
   
8.   * 2023-04-21     Wangyuqiang  the first version
   
9.   */
   
10. ​
    
11. #include <rtthread.h>
    
12. #include "spi_flash.h"
    
13. #include "spi_flash_sfud.h"
    
14. #include "drv_soft_spi.h"
    
15. #include "drv_pin.h"
    
16. #include "rtconfig.h"
    
17. ​
    
18. #define cs_pin  GET_PINS(1,9)
    
19. ​
    
20. static int rt_soft_spi_flash_init(void)
    
21. {
    
22.      int result = -1;
    
23. ​
    
24.      result = rt_hw_softspi_device_attach("sspi1", "sspi10", cs_pin);
    
25.      rt_kprintf("value is %d\n",result);
    
26.      
    
27.      if(result == RT_EOK)
    
28.      {
    
29.          rt_kprintf("rt_hw_softspi_device_attach successful!\n");
    
30.      }
    
31. ​
    
32.      if (RT_NULL == rt_sfud_flash_probe("W25Q128", "sspi10"))
    
33.      {
    
34.          return -RT_ERROR;
    
35.      }
    
36. ​
    
37.      return RT_EOK;
    
38. }
    
39. INIT_COMPONENT_EXPORT(rt_soft_spi_flash_init);

复制代码

这里我们需要指定一个片选引脚，我暂时使用了sspi2的SCK引脚作为片选，这里注意不要同时打开sspi1和sspi2，后续我会专门上传一个通用GPIO作为片选引脚，到时候就不会产生问题了。然后软件spi设备的挂载使用的是sspi1 bus及sspi10 device，并且挂载flash设备到sspi10。

另外我们在.\rt-thread\bsp\lpc55sxx\lpc55s69_nxp_evk\board\ports\下新建fal_sample.c文件，并编写测试代码：

1. //fal_sample.c
   
2. ​
   
3. /*
   
4.   * Copyright (c) 2006-2023, RT-Thread Development Team
   
5.   *
   
6.   * SPDX-License-Identifier: Apache-2.0
   
7.   *
   
8.   * Change Logs:
   
9.   * Date           Author       Notes
   
10.   * 2023-04-21     Wangyuqiang  the first version
    
11.   */
    
12.   
    
13. #include "rtthread.h"
    
14. #include "rtdevice.h"
    
15. #include "board.h"
    
16. #include "fal.h"
    
17. ​
    
18. #define BUF_SIZE 1024
    
19. ​
    
20. static int fal_test(const char *partiton_name)
    
21. {
    
22.      int ret;
    
23.      int i, j, len;
    
24.      uint8_t buf[BUF_SIZE];
    
25.      const struct fal_flash_dev *flash_dev = RT_NULL;
    
26.      const struct fal_partition *partition = RT_NULL;
    
27. ​
    
28.      if (!partiton_name)
    
29.      {
    
30.          rt_kprintf("Input param partition name is null!\n");
    
31.          return -1;
    
32.      }
    
33. ​
    
34.      partition = fal_partition_find(partiton_name);
    
35.      if (partition == RT_NULL)
    
36.      {
    
37.          rt_kprintf("Find partition (%s) failed!\n", partiton_name);
    
38.          ret = -1;
    
39.          return ret;
    
40.      }
    
41. ​
    
42.      flash_dev = fal_flash_device_find(partition->flash_name);
    
43.      if (flash_dev == RT_NULL)
    
44.      {
    
45.          rt_kprintf("Find flash device (%s) failed!\n", partition->flash_name);
    
46.          ret = -1;
    
47.          return ret;
    
48.      }
    
49. ​
    
50.      rt_kprintf("Flash device : %s   "
    
51.                 "Flash size : %dK   \n"
    
52.                 "Partition : %s   "
    
53.                 "Partition size: %dK\n",
    
54.                  partition->flash_name,
    
55.                  flash_dev->len/1024,
    
56.                  partition->name,
    
57.                  partition->len/1024);
    
58. ​
    
59.      /* erase all partition */
    
60.      ret = fal_partition_erase_all(partition);
    
61.      if (ret < 0)
    
62.      {
    
63.          rt_kprintf("Partition (%s) erase failed!\n", partition->name);
    
64.          ret = -1;
    
65.          return ret;
    
66.      }
    
67.      rt_kprintf("Erase (%s) partition finish!\n", partiton_name);
    
68. ​
    
69.      /* read the specified partition and check data */
    
70.      for (i = 0; i < partition->len;)
    
71.      {
    
72.          rt_memset(buf, 0x00, BUF_SIZE);
    
73. ​
    
74.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
    
75. ​
    
76.          ret = fal_partition_read(partition, i, buf, len);
    
77.          if (ret < 0)
    
78.          {
    
79.              rt_kprintf("Partition (%s) read failed!\n", partition->name);
    
80.              ret = -1;
    
81.              return ret;
    
82.          }
    
83. ​
    
84.          for(j = 0; j < len; j++)
    
85.          {
    
86.              if (buf[j] != 0xFF)
    
87.              {
    
88.                  rt_kprintf("The erase operation did not really succeed!\n");
    
89.                  ret = -1;
    
90.                  return ret;
    
91.              }
    
92.          }
    
93.          i += len;
    
94.      }
    
95. ​
    
96.      /* write 0x00 to the specified partition */
    
97.      for (i = 0; i < partition->len;)
    
98.      {
    
99.          rt_memset(buf, 0x00, BUF_SIZE);
    
100. ​
     
101.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
     
102. ​
     
103.          ret = fal_partition_write(partition, i, buf, len);
     
104.          if (ret < 0)
     
105.          {
     
106.              rt_kprintf("Partition (%s) write failed!\n", partition->name);
     
107.              ret = -1;
     
108.              return ret;
     
109.          }
     
110. ​
     
111.          i += len;
     
112.      }
     
113.      rt_kprintf("Write (%s) partition finish! Write size %d(%dK).\n", partiton_name, i, i/1024);
     
114. ​
     
115.      /* read the specified partition and check data */
     
116.      for (i = 0; i < partition->len;)
     
117.      {
     
118.          rt_memset(buf, 0xFF, BUF_SIZE);
     
119. ​
     
120.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
     
121. ​
     
122.          ret = fal_partition_read(partition, i, buf, len);
     
123.          if (ret < 0)
     
124.          {
     
125.              rt_kprintf("Partition (%s) read failed!\n", partition->name);
     
126.              ret = -1;
     
127.              return ret;
     
128.          }
     
129. ​
     
130.          for(j = 0; j < len; j++)
     
131.          {
     
132.              if (buf[j] != 0x00)
     
133.              {
     
134.                  rt_kprintf("The write operation did not really succeed!\n");
     
135.                  ret = -1;
     
136.                  return ret;
     
137.              }
     
138.          }
     
139. ​
     
140.          i += len;
     
141.      }
     
142. ​
     
143.      ret = 0;
     
144.      return ret;
     
145. }
     
146. ​
     
147. static void fal_sample(void)
     
148. {
     
149.      /* 1- init */
     
150.      fal_init();
     
151. ​
     
152.      if (fal_test("font") == 0)
     
153.      {
     
154.          rt_kprintf("Fal partition (%s) test success!\n", "font");
     
155.      }
     
156.      else
     
157.      {
     
158.          rt_kprintf("Fal partition (%s) test failed!\n", "font");
     
159.      }
     
160. ​
     
161.      if (fal_test("download") == 0)
     
162.      {
     
163.          rt_kprintf("Fal partition (%s) test success!\n", "download");
     
164.      }
     
165.      else
     
166.      {
     
167.          rt_kprintf("Fal partition (%s) test failed!\n", "download");
     
168.      }
     
169. }
     
170. MSH_CMD_EXPORT(fal_sample, fal sample);

复制代码

1.5 测试结果

打开串口工具，输入命令：

1. msh />fal_sample

复制代码

到这里就可以进行编译下载了，成功后的截图如下：

2.DFS文件系统

2.1 什么是DFS

DFS 是 RT-Thread 提供的虚拟文件系统组件，全称为 Device File System，即设备虚拟文件系统，文件系统的名称使用类似 UNIX 文件、文件夹的风格，目录结构如下图所示：

在 RT-Thread DFS 中，文件系统有统一的根目录，使用 / 来表示。而在根目录下的 f1.bin 文件则使用 /f1.bin 来表示，2018 目录下的 f1.bin 目录则使用 /data/2018/f1.bin 来表示。即目录的分割符号是 /，这与 UNIX/Linux 完全相同，与 Windows 则不相同（Windows 操作系统上使用 \ 来作为目录的分割符）。

2.2 DFS架构

RT-Thread DFS 组件的主要功能特点有：

• 为应用程序提供统一的 POSIX 文件和目录操作接口：read、write、poll/select 等。
• 支持多种类型的文件系统，如 FatFS、RomFS、DevFS 等，并提供普通文件、设备文件、网络文件描述符的管理。
• 支持多种类型的存储设备，如 SD Card、SPI Flash、Nand Flash 等。
  
  

DFS 的层次架构如下图所示，主要分为 POSIX 接口层、虚拟文件系统层和设备抽象层。

2.3 使用ENV配置DFS

打开ENV，进入路径RT-Thread Components → DFS: device virtual file system，使能 DFS: device virtual file system

由于DFS使用的是POSIX接口，而dfs_posix.h已经在新版本中被移除了，如果想要兼容老版本，可以在menuconfig中使能RT-Thread Components-> Support legacy version for compatibility

由于elmfat文件系统默认最大扇区大小为512，但我们使用的flash模块W25Q128的Flash扇区大小为4096，为了将elmfat文件系统挂载到W25Q128上，这里的Maximum sector size需要和W25Q128扇区大小保持一致，修改为4096，路径：RT-Thread Components → DFS: device virtual file system → Enable elm-chan fatfs / elm-chan's FatFs, Generic FAT Filesystem Module

保存退出后使用scons --target=mdk5生成MDK5工程。

2.4 DFS挂载到FAL分区测试

这里增加FAL flash抽象层，我们将elmfat文件系统挂载到W25Q128 flash设备的filesystem分区上，由于FAL管理的filesystem分区不是块设备，需要先使用FAL分区转BLK设备接口函数将filesystem分区转换为块设备，然后再将DFS elmfat文件系统挂载到filesystem块设备上。

我们接着修改fal_sample.c文件，修改后代码：

1. /*
   
2.   * Copyright (c) 2006-2023, RT-Thread Development Team
   
3.   *
   
4.   * SPDX-License-Identifier: Apache-2.0
   
5.   *
   
6.   * Change Logs:
   
7.   * Date           Author       Notes
   
8.   * 2023-04-21     Wangyuqiang  the first version
   
9.   */
   
10.   
    
11. #include "rtthread.h"
    
12. #include "rtdevice.h"
    
13. #include "board.h"
    
14. #include "fal.h"
    
15. ​
    
16. #include <dfs_posix.h>
    
17. ​
    
18. #define FS_PARTITION_NAME  "filesystem"
    
19. ​
    
20. #define BUF_SIZE 1024
    
21. ​
    
22. static int fal_test(const char *partiton_name)
    
23. {
    
24.      int ret;
    
25.      int i, j, len;
    
26.      uint8_t buf[BUF_SIZE];
    
27.      const struct fal_flash_dev *flash_dev = RT_NULL;
    
28.      const struct fal_partition *partition = RT_NULL;
    
29. ​
    
30.      if (!partiton_name)
    
31.      {
    
32.          rt_kprintf("Input param partition name is null!\n");
    
33.          return -1;
    
34.      }
    
35. ​
    
36.      partition = fal_partition_find(partiton_name);
    
37.      if (partition == RT_NULL)
    
38.      {
    
39.          rt_kprintf("Find partition (%s) failed!\n", partiton_name);
    
40.          ret = -1;
    
41.          return ret;
    
42.      }
    
43. ​
    
44.      flash_dev = fal_flash_device_find(partition->flash_name);
    
45.      if (flash_dev == RT_NULL)
    
46.      {
    
47.          rt_kprintf("Find flash device (%s) failed!\n", partition->flash_name);
    
48.          ret = -1;
    
49.          return ret;
    
50.      }
    
51. ​
    
52.      rt_kprintf("Flash device : %s   "
    
53.                 "Flash size : %dK   \n"
    
54.                 "Partition : %s   "
    
55.                 "Partition size: %dK\n",
    
56.                  partition->flash_name,
    
57.                  flash_dev->len/1024,
    
58.                  partition->name,
    
59.                  partition->len/1024);
    
60. ​
    
61.      /* erase all partition */
    
62.      ret = fal_partition_erase_all(partition);
    
63.      if (ret < 0)
    
64.      {
    
65.          rt_kprintf("Partition (%s) erase failed!\n", partition->name);
    
66.          ret = -1;
    
67.          return ret;
    
68.      }
    
69.      rt_kprintf("Erase (%s) partition finish!\n", partiton_name);
    
70. ​
    
71.      /* read the specified partition and check data */
    
72.      for (i = 0; i < partition->len;)
    
73.      {
    
74.          rt_memset(buf, 0x00, BUF_SIZE);
    
75. ​
    
76.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
    
77. ​
    
78.          ret = fal_partition_read(partition, i, buf, len);
    
79.          if (ret < 0)
    
80.          {
    
81.              rt_kprintf("Partition (%s) read failed!\n", partition->name);
    
82.              ret = -1;
    
83.              return ret;
    
84.          }
    
85. ​
    
86.          for(j = 0; j < len; j++)
    
87.          {
    
88.              if (buf[j] != 0xFF)
    
89.              {
    
90.                  rt_kprintf("The erase operation did not really succeed!\n");
    
91.                  ret = -1;
    
92.                  return ret;
    
93.              }
    
94.          }
    
95.          i += len;
    
96.      }
    
97. ​
    
98.      /* write 0x00 to the specified partition */
    
99.      for (i = 0; i < partition->len;)
    
100.      {
     
101.          rt_memset(buf, 0x00, BUF_SIZE);
     
102. ​
     
103.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
     
104. ​
     
105.          ret = fal_partition_write(partition, i, buf, len);
     
106.          if (ret < 0)
     
107.          {
     
108.              rt_kprintf("Partition (%s) write failed!\n", partition->name);
     
109.              ret = -1;
     
110.              return ret;
     
111.          }
     
112. ​
     
113.          i += len;
     
114.      }
     
115.      rt_kprintf("Write (%s) partition finish! Write size %d(%dK).\n", partiton_name, i, i/1024);
     
116. ​
     
117.      /* read the specified partition and check data */
     
118.      for (i = 0; i < partition->len;)
     
119.      {
     
120.          rt_memset(buf, 0xFF, BUF_SIZE);
     
121. ​
     
122.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
     
123. ​
     
124.          ret = fal_partition_read(partition, i, buf, len);
     
125.          if (ret < 0)
     
126.          {
     
127.              rt_kprintf("Partition (%s) read failed!\n", partition->name);
     
128.              ret = -1;
     
129.              return ret;
     
130.          }
     
131. ​
     
132.          for(j = 0; j < len; j++)
     
133.          {
     
134.              if (buf[j] != 0x00)
     
135.              {
     
136.                  rt_kprintf("The write operation did not really succeed!\n");
     
137.                  ret = -1;
     
138.                  return ret;
     
139.              }
     
140.          }
     
141. ​
     
142.          i += len;
     
143.      }
     
144. ​
     
145.      ret = 0;
     
146.      return ret;
     
147. }
     
148. ​
     
149. static void fal_sample(void)
     
150. {
     
151.      /* 1- init */
     
152.      fal_init();
     
153. ​
     
154.      if (fal_test("font") == 0)
     
155.      {
     
156.          rt_kprintf("Fal partition (%s) test success!\n", "font");
     
157.      }
     
158.      else
     
159.      {
     
160.          rt_kprintf("Fal partition (%s) test failed!\n", "font");
     
161.      }
     
162. ​
     
163.      if (fal_test("download") == 0)
     
164.      {
     
165.          rt_kprintf("Fal partition (%s) test success!\n", "download");
     
166.      }
     
167.      else
     
168.      {
     
169.          rt_kprintf("Fal partition (%s) test failed!\n", "download");
     
170.      }
     
171. }
     
172. MSH_CMD_EXPORT(fal_sample, fal sample);
     
173. ​
     
174. static void fal_elmfat_sample(void)
     
175. {
     
176.      int fd, size;
     
177.      struct statfs elm_stat;
     
178.      struct fal_blk_device *blk_dev;
     
179.      char str[] = "elmfat mount to W25Q flash.", buf[80];
     
180. ​
     
181.      /* fal init */
     
182.      fal_init();
     
183. ​
     
184.      /* create block device */
     
185.      blk_dev = (struct fal_blk_device *)fal_blk_device_create(FS_PARTITION_NAME);
     
186.      if(blk_dev == RT_NULL)
     
187.          rt_kprintf("Can't create a block device on '%s' partition.\n", FS_PARTITION_NAME);
     
188.      else
     
189.          rt_kprintf("Create a block device on the %s partition of flash successful.\n", FS_PARTITION_NAME);
     
190. ​
     
191.      /* make a elmfat format filesystem */
     
192.      if(dfs_mkfs("elm", FS_PARTITION_NAME) == 0)
     
193.          rt_kprintf("make elmfat filesystem success.\n");
     
194. ​
     
195.      /* mount elmfat file system to FS_PARTITION_NAME */
     
196.      if(dfs_mount(FS_PARTITION_NAME, "/", "elm", 0, 0) == 0)
     
197.          rt_kprintf("elmfat filesystem mount success.\n");
     
198. ​
     
199.      /* Get elmfat file system statistics */
     
200.      if(statfs("/", &elm_stat) == 0)
     
201.          rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
     
202.                      elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
     
203. ​
     
204.      if(mkdir("/user", 0x777) == 0)
     
205.          rt_kprintf("make a directory: '/user'.\n");
     
206. ​
     
207.      rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
     
208. ​
     
209.      /* Open the file in create and read-write mode, create the file if it does not exist*/
     
210.      fd = open("/user/test.txt", O_WRONLY | O_CREAT);
     
211.      if (fd >= 0)
     
212.      {
     
213.          if(write(fd, str, sizeof(str)) == sizeof(str))
     
214.              rt_kprintf("Write data done.\n");
     
215. ​
     
216.          close(fd);   
     
217.      }
     
218. ​
     
219.      /* Open file in read-only mode */
     
220.      fd = open("/user/test.txt", O_RDONLY);
     
221.      if (fd >= 0)
     
222.      {
     
223.          size = read(fd, buf, sizeof(buf));
     
224. ​
     
225.          close(fd);
     
226. ​
     
227.          if(size == sizeof(str))
     
228.              rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
     
229.      }
     
230. }
     
231. MSH_CMD_EXPORT_ALIAS(fal_elmfat_sample, fal_elmfat,fal elmfat sample);

复制代码

2.5 测试结果
打开串口工具，输入命令：

1. msh />fal_elmfat_sample

复制代码

测试结果如下：

3.Easyflash移植到FAL分区

3.1 简述EasyFlash

关于EasyFlash的来源我们已经讲过了，此处不再赘述。EasyFlash是一款开源的轻量级嵌入式Flash存储器库，方便开发者更加轻松的实现基于Flash存储器的常见应用开发。非常适合智能家居、可穿戴、工控、医疗、物联网等需要断电存储功能的产品，资源占用极低，支持各种 MCU 片上存储器。

EasyFlash不仅能够实现对产品的 设定参数 或 运行日志 等信息的掉电保存功能，还封装了简洁的 增加、删除、修改及查询 方法， 降低了开发者对产品参数的处理难度，也保证了产品在后期升级时拥有更好的扩展性。让Flash变为NoSQL（非关系型数据库）模型的小型键值（Key-Value）存储数据库。

3.2EasyFlash软件包使用

打开ENV进入路径：RT-Thread online packages → tools packages → EasyFlash: Lightweight embedded flash memory library.，选择软件包版本为最新版。

配置后退出ENV，同时使用pkgs --update下载软件包，然后再使用scons --target=mdk5重新生成MDK5文件

3.3 移植easyflash

下载完easyflash软件包后，我们复制.\rt-thread\bsp\lpc55sxx\lpc55s69_nxp_evk\packages\EasyFlash-latest\ports\ef_fal_port.c到目录.\rt-thread\bsp\lpc55sxx\lpc55s69_nxp_evk\board\ports\easyflash\ef_fal_port.c，双击打开该文件，完成以下修改：

1. // 修改 FAL_EF_PART_NAME 为 easyflash
   
2. #define FAL_EF_PART_NAME               "easyflash"

复制代码

3.4 编写Easyflash测试用例

1. /*
   
2.   * Copyright (c) 2006-2023, RT-Thread Development Team
   
3.   *
   
4.   * SPDX-License-Identifier: Apache-2.0
   
5.   *
   
6.   * Change Logs:
   
7.   * Date           Author       Notes
   
8.   * 2023-04-21     Wangyuqiang  the first version
   
9.   */
   
10.   
    
11. #include "rtthread.h"
    
12. #include "rtdevice.h"
    
13. #include "board.h"
    
14. #include "fal.h"
    
15. ​
    
16. #include <dfs_posix.h>
    
17. ​
    
18. #include "easyflash.h"
    
19. #include <stdlib.h>
    
20. ​
    
21. #define FS_PARTITION_NAME  "filesystem"
    
22. ​
    
23. #define BUF_SIZE 1024
    
24. ​
    
25. static int fal_test(const char *partiton_name)
    
26. {
    
27.      int ret;
    
28.      int i, j, len;
    
29.      uint8_t buf[BUF_SIZE];
    
30.      const struct fal_flash_dev *flash_dev = RT_NULL;
    
31.      const struct fal_partition *partition = RT_NULL;
    
32. ​
    
33.      if (!partiton_name)
    
34.      {
    
35.          rt_kprintf("Input param partition name is null!\n");
    
36.          return -1;
    
37.      }
    
38. ​
    
39.      partition = fal_partition_find(partiton_name);
    
40.      if (partition == RT_NULL)
    
41.      {
    
42.          rt_kprintf("Find partition (%s) failed!\n", partiton_name);
    
43.          ret = -1;
    
44.          return ret;
    
45.      }
    
46. ​
    
47.      flash_dev = fal_flash_device_find(partition->flash_name);
    
48.      if (flash_dev == RT_NULL)
    
49.      {
    
50.          rt_kprintf("Find flash device (%s) failed!\n", partition->flash_name);
    
51.          ret = -1;
    
52.          return ret;
    
53.      }
    
54. ​
    
55.      rt_kprintf("Flash device : %s   "
    
56.                 "Flash size : %dK   \n"
    
57.                 "Partition : %s   "
    
58.                 "Partition size: %dK\n",
    
59.                  partition->flash_name,
    
60.                  flash_dev->len/1024,
    
61.                  partition->name,
    
62.                  partition->len/1024);
    
63. ​
    
64.      /* erase all partition */
    
65.      ret = fal_partition_erase_all(partition);
    
66.      if (ret < 0)
    
67.      {
    
68.          rt_kprintf("Partition (%s) erase failed!\n", partition->name);
    
69.          ret = -1;
    
70.          return ret;
    
71.      }
    
72.      rt_kprintf("Erase (%s) partition finish!\n", partiton_name);
    
73. ​
    
74.      /* read the specified partition and check data */
    
75.      for (i = 0; i < partition->len;)
    
76.      {
    
77.          rt_memset(buf, 0x00, BUF_SIZE);
    
78. ​
    
79.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
    
80. ​
    
81.          ret = fal_partition_read(partition, i, buf, len);
    
82.          if (ret < 0)
    
83.          {
    
84.              rt_kprintf("Partition (%s) read failed!\n", partition->name);
    
85.              ret = -1;
    
86.              return ret;
    
87.          }
    
88. ​
    
89.          for(j = 0; j < len; j++)
    
90.          {
    
91.              if (buf[j] != 0xFF)
    
92.              {
    
93.                  rt_kprintf("The erase operation did not really succeed!\n");
    
94.                  ret = -1;
    
95.                  return ret;
    
96.              }
    
97.          }
    
98.          i += len;
    
99.      }
    
100. ​
     
101.      /* write 0x00 to the specified partition */
     
102.      for (i = 0; i < partition->len;)
     
103.      {
     
104.          rt_memset(buf, 0x00, BUF_SIZE);
     
105. ​
     
106.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
     
107. ​
     
108.          ret = fal_partition_write(partition, i, buf, len);
     
109.          if (ret < 0)
     
110.          {
     
111.              rt_kprintf("Partition (%s) write failed!\n", partition->name);
     
112.              ret = -1;
     
113.              return ret;
     
114.          }
     
115. ​
     
116.          i += len;
     
117.      }
     
118.      rt_kprintf("Write (%s) partition finish! Write size %d(%dK).\n", partiton_name, i, i/1024);
     
119. ​
     
120.      /* read the specified partition and check data */
     
121.      for (i = 0; i < partition->len;)
     
122.      {
     
123.          rt_memset(buf, 0xFF, BUF_SIZE);
     
124. ​
     
125.          len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);
     
126. ​
     
127.          ret = fal_partition_read(partition, i, buf, len);
     
128.          if (ret < 0)
     
129.          {
     
130.              rt_kprintf("Partition (%s) read failed!\n", partition->name);
     
131.              ret = -1;
     
132.              return ret;
     
133.          }
     
134. ​
     
135.          for(j = 0; j < len; j++)
     
136.          {
     
137.              if (buf[j] != 0x00)
     
138.              {
     
139.                  rt_kprintf("The write operation did not really succeed!\n");
     
140.                  ret = -1;
     
141.                  return ret;
     
142.              }
     
143.          }
     
144. ​
     
145.          i += len;
     
146.      }
     
147. ​
     
148.      ret = 0;
     
149.      return ret;
     
150. }
     
151. ​
     
152. static void fal_sample(void)
     
153. {
     
154.      /* 1- init */
     
155.      fal_init();
     
156. ​
     
157.      if (fal_test("font") == 0)
     
158.      {
     
159.          rt_kprintf("Fal partition (%s) test success!\n", "font");
     
160.      }
     
161.      else
     
162.      {
     
163.          rt_kprintf("Fal partition (%s) test failed!\n", "font");
     
164.      }
     
165. ​
     
166.      if (fal_test("download") == 0)
     
167.      {
     
168.          rt_kprintf("Fal partition (%s) test success!\n", "download");
     
169.      }
     
170.      else
     
171.      {
     
172.          rt_kprintf("Fal partition (%s) test failed!\n", "download");
     
173.      }
     
174. }
     
175. MSH_CMD_EXPORT(fal_sample, fal sample);
     
176. ​
     
177. static void fal_elmfat_sample(void)
     
178. {
     
179.      int fd, size;
     
180.      struct statfs elm_stat;
     
181.      struct fal_blk_device *blk_dev;
     
182.      char str[] = "elmfat mount to W25Q flash.", buf[80];
     
183. ​
     
184.      /* fal init */
     
185.      fal_init();
     
186. ​
     
187.      /* create block device */
     
188.      blk_dev = (struct fal_blk_device *)fal_blk_device_create(FS_PARTITION_NAME);
     
189.      if(blk_dev == RT_NULL)
     
190.          rt_kprintf("Can't create a block device on '%s' partition.\n", FS_PARTITION_NAME);
     
191.      else
     
192.          rt_kprintf("Create a block device on the %s partition of flash successful.\n", FS_PARTITION_NAME);
     
193. ​
     
194.      /* make a elmfat format filesystem */
     
195.      if(dfs_mkfs("elm", FS_PARTITION_NAME) == 0)
     
196.          rt_kprintf("make elmfat filesystem success.\n");
     
197. ​
     
198.      /* mount elmfat file system to FS_PARTITION_NAME */
     
199.      if(dfs_mount(FS_PARTITION_NAME, "/", "elm", 0, 0) == 0)
     
200.          rt_kprintf("elmfat filesystem mount success.\n");
     
201. ​
     
202.      /* Get elmfat file system statistics */
     
203.      if(statfs("/", &elm_stat) == 0)
     
204.          rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
     
205.                      elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
     
206. ​
     
207.      if(mkdir("/user", 0x777) == 0)
     
208.          rt_kprintf("make a directory: '/user'.\n");
     
209. ​
     
210.      rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
     
211. ​
     
212.      /* Open the file in create and read-write mode, create the file if it does not exist*/
     
213.      fd = open("/user/test.txt", O_WRONLY | O_CREAT);
     
214.      if (fd >= 0)
     
215.      {
     
216.          if(write(fd, str, sizeof(str)) == sizeof(str))
     
217.              rt_kprintf("Write data done.\n");
     
218. ​
     
219.          close(fd);   
     
220.      }
     
221. ​
     
222.      /* Open file in read-only mode */
     
223.      fd = open("/user/test.txt", O_RDONLY);
     
224.      if (fd >= 0)
     
225.      {
     
226.          size = read(fd, buf, sizeof(buf));
     
227. ​
     
228.          close(fd);
     
229. ​
     
230.          if(size == sizeof(str))
     
231.              rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
     
232.      }
     
233. }
     
234. MSH_CMD_EXPORT_ALIAS(fal_elmfat_sample, fal_elmfat,fal elmfat sample);
     
235. ​
     
236. static void easyflash_sample(void)
     
237. {
     
238.      /* fal init */
     
239.      fal_init();
     
240. ​
     
241.      /* easyflash init */
     
242.      if(easyflash_init() == EF_NO_ERR)
     
243.      {
     
244.          uint32_t i_boot_times = NULL;
     
245.          char *c_old_boot_times, c_new_boot_times[11] = {0};
     
246. ​
     
247.          /* get the boot count number from Env */
     
248.          c_old_boot_times = ef_get_env("boot_times");
     
249.          /* get the boot count number failed */
     
250.          if (c_old_boot_times == RT_NULL)
     
251.              c_old_boot_times[0] = '0';
     
252. ​
     
253.          i_boot_times = atol(c_old_boot_times);
     
254.          /* boot count +1 */
     
255.          i_boot_times ++;
     
256.          rt_kprintf("===============================================\n");
     
257.          rt_kprintf("The system now boot %d times\n", i_boot_times);
     
258.          rt_kprintf("===============================================\n");
     
259.          /* interger to string */
     
260.          sprintf(c_new_boot_times, "%d", i_boot_times);
     
261.          /* set and store the boot count number to Env */
     
262.          ef_set_env("boot_times", c_new_boot_times);
     
263.          ef_save_env();
     
264.      }
     
265. }
     
266. MSH_CMD_EXPORT(easyflash_sample, easyflash sample);

复制代码

3.5 测试结果

打开串口助手，输入命令：

1. msh />easyflash_sample

复制代码

第一次命令调用：

第二次RESET开发板后调用：

4.结语

至此本博客就到此结束，经历从移植软件模拟spi框架到LPC55S69，到移植过程中遇到不断的问题，到最后解决所有问题并提供应用示例，完成开发日记、开发笔记及应用教学，这个过程确实使我受益良多，其中感受最深的就是当然也更加感谢的是一些前辈们的指点迷津和博文记录，就目前国内嵌入式这个领域，相关开发经验相比较其他计算机行业确实有些不够包容和开放，也希望未来的朋友们能够怀揣着一颗求知及授学之心，共同建设好这个领域！

5.联系

• Email :yifang.wangyq@foxmail.com
• Github Address :https://github.com/kurisaW
• My Website :https://kurisaw.github.io
  
  

参考资料：

• IOT-OS之RT-Thread（十一）--- FAL分区管理与easyflash变量管理
• RT-Thread文档中心：FAL组件
  
  

阅读全文

NXP管管

赞一下，非常详细啊！

suncat0504

学习。之前对恩智浦的开发板不熟悉（老早以前用过iMX280，Linux下的开发，不知道是不是恩智浦的），有了楼主共享的资料，有机会要尝试下。谢谢！

mgn

感谢分享~

以放

目前lpcsxx系列已完成软件spi框架的对接，用户可以在RT-Thread的设备框架下驱动软件spi了，也欢迎大家积极使用RTT，开发过程中的相关问题可随时与我取得联系！

以放

NXP管管 发表于 2023-4-24 09:35
赞一下，非常详细啊！

感谢支持

以放

suncat0504 发表于 2023-4-24 10:54
学习。之前对恩智浦的开发板不熟悉（老早以前用过iMX280，Linux下的开发，不知道是不是恩智浦的），有了楼 ...

欢迎评测，如果开发过程中有遇到相关问题可以相互探讨交流哇！

eefocus_3914144

辛苦了，我想参与项目，通过什么试呢？

linghz

感谢分享

lxl666

不错，支持一下！