使用FAL分区管理与easyflash变量管理

最新推荐文章于 2024-10-09 18:19:09 发布
最新推荐文章于 2024-10-09 18:19:09 发布
阅读量423 收藏 16
点赞数 9
文章标签： mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rtthreadiotos/article/details/142800681
版权

1.

FAL组件

1.1

什么是FAL

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

  • 支持静态可配置的分区表，并可关联多个 Flash 设备;

  • 分区表支持 自动装载 。避免在多固件项目，分区表被多次定义的问题；

  • 代码精简，对操作系统 无依赖 ，可运行于裸机平台，比如对资源有一定要求的 Bootloader;

  • 统一的操作接口。保证了文件系统、OTA、NVM（例如：EasyFlash https://github.com/armink-rtt-pkgs/EasyFlash） 等对 Flash 有一定依赖的组件，底层 Flash 驱动的可重用性;

  • 自带基于 Finsh/MSH 的测试命令，可以通过 Shell 按字节寻址的方式操作（读写擦） Flash 或分区，方便开发者进行调试、测试;

903a26aeccaafc689d4558e8ed898092.png

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

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

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

927621fa72de0f00e52dd7aa16843b29.png

来源：ROM、RAM、FLASH、NVM......一文搞定（https://blog.csdn.net/lianyunyouyou/article/details/118277207)

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.

7cd1cec4dc32a29a72c5643238f105a1.png

完成上述操作后保存退出，并使用 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

// fal.cfg.h


/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-04-21     Wangyuqiang  the first version
 */
#ifndef _FAL_CFG_H_
#define _FAL_CFG_H_


#include <rtthread.h>
#include <board.h>


#ifndef FAL_USING_NOR_FLASH_DEV_NAME
#define NOR_FLASH_DEV_NAME             "norflash0"
#else
#define NOR_FLASH_DEV_NAME              FAL_USING_NOR_FLASH_DEV_NAME
#endif


/* Flash device Configuration */


extern struct fal_flash_dev nor_flash0;


/* flash device table */


#define FAL_FLASH_DEV_TABLE                                          \
{                                                                    \
    &nor_flash0,                                                     \
}


/* Partition Configuration */


#ifdef FAL_PART_HAS_TABLE_CFG


/* partition table */


#define FAL_PART_TABLE                                                                                                  \
{                                                                                                                       \
    {FAL_PART_MAGIC_WROD,  "easyflash", NOR_FLASH_DEV_NAME,                                    0,       512 * 1024, 0}, \
    {FAL_PART_MAGIC_WROD,   "download", NOR_FLASH_DEV_NAME,                           512 * 1024,      1024 * 1024, 0}, \
    {FAL_PART_MAGIC_WROD, "wifi_image", NOR_FLASH_DEV_NAME,                  (512 + 1024) * 1024,       512 * 1024, 0}, \
    {FAL_PART_MAGIC_WROD,       "font", NOR_FLASH_DEV_NAME,            (512 + 1024 + 512) * 1024,  7 * 1024 * 1024, 0}, \
    {FAL_PART_MAGIC_WROD, "filesystem", NOR_FLASH_DEV_NAME, (512 + 1024 + 512 + 7 * 1024) * 1024,  7 * 1024 * 1024, 0}, \
}
#endif /* FAL_PART_HAS_TABLE_CFG */


#endif /* _FAL_CFG_H_ */

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

af776b1cf1919d965f2f7e6922ec8b7e.png

在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 进行修改：

struct fal_flash_dev nor_flash0 =
{
    .name       = FAL_USING_NOR_FLASH_DEV_NAME,
    .addr       = 0,
    .len        = 16 * 1024 * 1024,
    .blk_size   = 4096,
    .ops        = {init, read, write, erase},
    .write_gran = 1
};

当然也可以选择不进行修改，根据大佬的原话就是因为在调用初始化接口函数init后，会从flash设备读取正确的参数更新到nor_flash0表项中，我们在使用FAL组件前都需要调用FAL初始化函数fal_init，其内调用flash设备初始化函数fal_flash_init，最后会调用注册到fal_flash_dev设备表项中的初始化函数device_table[i]->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引脚定义可以选用默认即可，当然也可以使用自定义引脚，记住不要与其他引脚产生冲突。

b8e9a23dae5b0d8ba4130a29c1affdd1.png

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

9e37f357f2f210855a0e95ab74d102eb.png

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

1.4

FAL SFUD 测试用例

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

/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-04-21     Wangyuqiang  the first version
 */


#include <rtthread.h>
#include "spi_flash.h"
#include "spi_flash_sfud.h"
#include "drv_soft_spi.h"
#include "drv_pin.h"
#include "rtconfig.h"


#define cs_pin  GET_PINS(1,9)


static int rt_soft_spi_flash_init(void)
{
  int result = -1;


    result = rt_hw_softspi_device_attach("sspi1", "sspi10", cs_pin);
  rt_kprintf("value is %d\n",result);
  
  if(result == RT_EOK)
  {
    rt_kprintf("rt_hw_softspi_device_attach successful!\n");
  }


    if (RT_NULL == rt_sfud_flash_probe("W25Q128", "sspi10"))
    {
        return -RT_ERROR;
    }


    return RT_EOK;
}
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 文件，并编写测试代码：

//fal_sample.c


/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-04-21     Wangyuqiang  the first version
 */
 
#include "rtthread.h"
#include "rtdevice.h"
#include "board.h"
#include "fal.h"


#define BUF_SIZE 1024


static int fal_test(const char *partiton_name)
{
    int ret;
    int i, j, len;
    uint8_t buf[BUF_SIZE];
    const struct fal_flash_dev *flash_dev = RT_NULL;
    const struct fal_partition *partition = RT_NULL;


    if (!partiton_name)
    {
        rt_kprintf("Input param partition name is null!\n");
        return -1;
    }


    partition = fal_partition_find(partiton_name);
    if (partition == RT_NULL)
    {
        rt_kprintf("Find partition (%s) failed!\n", partiton_name);
        ret = -1;
        return ret;
    }


    flash_dev = fal_flash_device_find(partition->flash_name);
    if (flash_dev == RT_NULL)
    {
        rt_kprintf("Find flash device (%s) failed!\n", partition->flash_name);
        ret = -1;
        return ret;
    }


    rt_kprintf("Flash device : %s   "
               "Flash size : %dK   \n"
               "Partition : %s   "
               "Partition size: %dK\n", 
                partition->flash_name, 
                flash_dev->len/1024,
                partition->name,
                partition->len/1024);


    /* erase all partition */
    ret = fal_partition_erase_all(partition);
    if (ret < 0)
    {
        rt_kprintf("Partition (%s) erase failed!\n", partition->name);
        ret = -1;
        return ret;
    }
    rt_kprintf("Erase (%s) partition finish!\n", partiton_name);


    /* read the specified partition and check data */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0x00, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_read(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) read failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        for(j = 0; j < len; j++)
        {
            if (buf[j] != 0xFF)
            {
                rt_kprintf("The erase operation did not really succeed!\n");
                ret = -1;
                return ret;
            }
        }
        i += len;
    }


    /* write 0x00 to the specified partition */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0x00, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_write(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) write failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        i += len;
    }
    rt_kprintf("Write (%s) partition finish! Write size %d(%dK).\n", partiton_name, i, i/1024);


    /* read the specified partition and check data */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0xFF, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_read(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) read failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        for(j = 0; j < len; j++)
        {
            if (buf[j] != 0x00)
            {
                rt_kprintf("The write operation did not really succeed!\n");
                ret = -1;
                return ret;
            }
        }


        i += len;
    }


    ret = 0;
    return ret;
}


static void fal_sample(void)
{
    /* 1- init */
    fal_init();


    if (fal_test("font") == 0)
    {
        rt_kprintf("Fal partition (%s) test success!\n", "font");
    }
    else
    {
        rt_kprintf("Fal partition (%s) test failed!\n", "font");
    }


    if (fal_test("download") == 0)
    {
        rt_kprintf("Fal partition (%s) test success!\n", "download");
    }
    else
    {
        rt_kprintf("Fal partition (%s) test failed!\n", "download");
    }
}
MSH_CMD_EXPORT(fal_sample, fal sample);

1.5

测试结果

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

e88f9a4c3f02f9c70189c637b5daacfe.png

2.

DFS文件系统

2.1

什么是DFS

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

f410b554be1f10dfaf19ca75bda06487.png

在 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 接口层、虚拟文件系统层和设备抽象层。

c5d36ea97ecd478de4dc3b093a38c3ba.png

2.3

使用ENV配置DFS

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

74b8e73ee67f3d45294bfcad8b42cd60.png

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

cd5920d4b15121d0f2b69225262e57ba.png

由于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

276fc3e065932ba5e90f78b8000c3494.png

保存退出后使用 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文件，修改后代码：

/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-04-21     Wangyuqiang  the first version
 */
 
#include "rtthread.h"
#include "rtdevice.h"
#include "board.h"
#include "fal.h"


#include <dfs_posix.h>


#define FS_PARTITION_NAME  "filesystem"


#define BUF_SIZE 1024


static int fal_test(const char *partiton_name)
{
    int ret;
    int i, j, len;
    uint8_t buf[BUF_SIZE];
    const struct fal_flash_dev *flash_dev = RT_NULL;
    const struct fal_partition *partition = RT_NULL;


    if (!partiton_name)
    {
        rt_kprintf("Input param partition name is null!\n");
        return -1;
    }


    partition = fal_partition_find(partiton_name);
    if (partition == RT_NULL)
    {
        rt_kprintf("Find partition (%s) failed!\n", partiton_name);
        ret = -1;
        return ret;
    }


    flash_dev = fal_flash_device_find(partition->flash_name);
    if (flash_dev == RT_NULL)
    {
        rt_kprintf("Find flash device (%s) failed!\n", partition->flash_name);
        ret = -1;
        return ret;
    }


    rt_kprintf("Flash device : %s   "
               "Flash size : %dK   \n"
               "Partition : %s   "
               "Partition size: %dK\n", 
                partition->flash_name, 
                flash_dev->len/1024,
                partition->name,
                partition->len/1024);


    /* erase all partition */
    ret = fal_partition_erase_all(partition);
    if (ret < 0)
    {
        rt_kprintf("Partition (%s) erase failed!\n", partition->name);
        ret = -1;
        return ret;
    }
    rt_kprintf("Erase (%s) partition finish!\n", partiton_name);


    /* read the specified partition and check data */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0x00, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_read(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) read failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        for(j = 0; j < len; j++)
        {
            if (buf[j] != 0xFF)
            {
                rt_kprintf("The erase operation did not really succeed!\n");
                ret = -1;
                return ret;
            }
        }
        i += len;
    }


    /* write 0x00 to the specified partition */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0x00, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_write(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) write failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        i += len;
    }
    rt_kprintf("Write (%s) partition finish! Write size %d(%dK).\n", partiton_name, i, i/1024);


    /* read the specified partition and check data */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0xFF, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_read(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) read failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        for(j = 0; j < len; j++)
        {
            if (buf[j] != 0x00)
            {
                rt_kprintf("The write operation did not really succeed!\n");
                ret = -1;
                return ret;
            }
        }


        i += len;
    }


    ret = 0;
    return ret;
}


static void fal_sample(void)
{
    /* 1- init */
    fal_init();


    if (fal_test("font") == 0)
    {
        rt_kprintf("Fal partition (%s) test success!\n", "font");
    }
    else
    {
        rt_kprintf("Fal partition (%s) test failed!\n", "font");
    }


    if (fal_test("download") == 0)
    {
        rt_kprintf("Fal partition (%s) test success!\n", "download");
    }
    else
    {
        rt_kprintf("Fal partition (%s) test failed!\n", "download");
    }
}
MSH_CMD_EXPORT(fal_sample, fal sample);


static void fal_elmfat_sample(void)
{
    int fd, size;
    struct statfs elm_stat;
    struct fal_blk_device *blk_dev;
    char str[] = "elmfat mount to W25Q flash.", buf[80];


    /* fal init */
    fal_init();


    /* create block device */
    blk_dev = (struct fal_blk_device *)fal_blk_device_create(FS_PARTITION_NAME);
    if(blk_dev == RT_NULL)
        rt_kprintf("Can't create a block device on '%s' partition.\n", FS_PARTITION_NAME);
    else
        rt_kprintf("Create a block device on the %s partition of flash successful.\n", FS_PARTITION_NAME);


    /* make a elmfat format filesystem */
    if(dfs_mkfs("elm", FS_PARTITION_NAME) == 0)
        rt_kprintf("make elmfat filesystem success.\n");


    /* mount elmfat file system to FS_PARTITION_NAME */
    if(dfs_mount(FS_PARTITION_NAME, "/", "elm", 0, 0) == 0)
        rt_kprintf("elmfat filesystem mount success.\n");


    /* Get elmfat file system statistics */
    if(statfs("/", &elm_stat) == 0)
        rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n", 
                    elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);


    if(mkdir("/user", 0x777) == 0)
        rt_kprintf("make a directory: '/user'.\n");


    rt_kprintf("Write string '%s' to /user/test.txt.\n", str);


    /* Open the file in create and read-write mode, create the file if it does not exist*/
    fd = open("/user/test.txt", O_WRONLY | O_CREAT);
    if (fd >= 0)
    {
        if(write(fd, str, sizeof(str)) == sizeof(str))
            rt_kprintf("Write data done.\n");


        close(fd);   
    }


    /* Open file in read-only mode */
    fd = open("/user/test.txt", O_RDONLY);
    if (fd >= 0)
    {
        size = read(fd, buf, sizeof(buf));


        close(fd);


        if(size == sizeof(str))
            rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
    }
}
MSH_CMD_EXPORT_ALIAS(fal_elmfat_sample, fal_elmfat,fal elmfat sample);

2.5

测试结果

测试结果如下：

ff77512b13fa615ddd6908e0c7431940.png

3.

Easyflash移植到FAL分区

3.1

简述EasyFlash

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

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

3.2

EasyFlash软件包使用

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

0cdf5f78f933d7f75f9d726816d800bb.png

配置后退出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 ，双击打开该文件，完成以下修改：

// 修改 FAL_EF_PART_NAME 为 easyflash
#define FAL_EF_PART_NAME               "easyflash"
// 修改环境变量内容为 {"boot_times", "0"}，这里我们先只设置一个开机次数
static const ef_env default_env_set[] = {
        {"boot_times", "0"},
};

3.4

编写Easyflash测试用例

/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-04-21     Wangyuqiang  the first version
 */
 
#include "rtthread.h"
#include "rtdevice.h"
#include "board.h"
#include "fal.h"


#include <dfs_posix.h>


#include "easyflash.h"
#include <stdlib.h>


#define FS_PARTITION_NAME  "filesystem"


#define BUF_SIZE 1024


static int fal_test(const char *partiton_name)
{
    int ret;
    int i, j, len;
    uint8_t buf[BUF_SIZE];
    const struct fal_flash_dev *flash_dev = RT_NULL;
    const struct fal_partition *partition = RT_NULL;


    if (!partiton_name)
    {
        rt_kprintf("Input param partition name is null!\n");
        return -1;
    }


    partition = fal_partition_find(partiton_name);
    if (partition == RT_NULL)
    {
        rt_kprintf("Find partition (%s) failed!\n", partiton_name);
        ret = -1;
        return ret;
    }


    flash_dev = fal_flash_device_find(partition->flash_name);
    if (flash_dev == RT_NULL)
    {
        rt_kprintf("Find flash device (%s) failed!\n", partition->flash_name);
        ret = -1;
        return ret;
    }


    rt_kprintf("Flash device : %s   "
               "Flash size : %dK   \n"
               "Partition : %s   "
               "Partition size: %dK\n", 
                partition->flash_name, 
                flash_dev->len/1024,
                partition->name,
                partition->len/1024);


    /* erase all partition */
    ret = fal_partition_erase_all(partition);
    if (ret < 0)
    {
        rt_kprintf("Partition (%s) erase failed!\n", partition->name);
        ret = -1;
        return ret;
    }
    rt_kprintf("Erase (%s) partition finish!\n", partiton_name);


    /* read the specified partition and check data */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0x00, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_read(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) read failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        for(j = 0; j < len; j++)
        {
            if (buf[j] != 0xFF)
            {
                rt_kprintf("The erase operation did not really succeed!\n");
                ret = -1;
                return ret;
            }
        }
        i += len;
    }


    /* write 0x00 to the specified partition */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0x00, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_write(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) write failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        i += len;
    }
    rt_kprintf("Write (%s) partition finish! Write size %d(%dK).\n", partiton_name, i, i/1024);


    /* read the specified partition and check data */
    for (i = 0; i < partition->len;)
    {
        rt_memset(buf, 0xFF, BUF_SIZE);


        len = (partition->len - i) > BUF_SIZE ? BUF_SIZE : (partition->len - i);


        ret = fal_partition_read(partition, i, buf, len);
        if (ret < 0)
        {
            rt_kprintf("Partition (%s) read failed!\n", partition->name);
            ret = -1;
            return ret;
        }


        for(j = 0; j < len; j++)
        {
            if (buf[j] != 0x00)
            {
                rt_kprintf("The write operation did not really succeed!\n");
                ret = -1;
                return ret;
            }
        }


        i += len;
    }


    ret = 0;
    return ret;
}


static void fal_sample(void)
{
    /* 1- init */
    fal_init();


    if (fal_test("font") == 0)
    {
        rt_kprintf("Fal partition (%s) test success!\n", "font");
    }
    else
    {
        rt_kprintf("Fal partition (%s) test failed!\n", "font");
    }


    if (fal_test("download") == 0)
    {
        rt_kprintf("Fal partition (%s) test success!\n", "download");
    }
    else
    {
        rt_kprintf("Fal partition (%s) test failed!\n", "download");
    }
}
MSH_CMD_EXPORT(fal_sample, fal sample);


static void fal_elmfat_sample(void)
{
    int fd, size;
    struct statfs elm_stat;
    struct fal_blk_device *blk_dev;
    char str[] = "elmfat mount to W25Q flash.", buf[80];


    /* fal init */
    fal_init();


    /* create block device */
    blk_dev = (struct fal_blk_device *)fal_blk_device_create(FS_PARTITION_NAME);
    if(blk_dev == RT_NULL)
        rt_kprintf("Can't create a block device on '%s' partition.\n", FS_PARTITION_NAME);
    else
        rt_kprintf("Create a block device on the %s partition of flash successful.\n", FS_PARTITION_NAME);


    /* make a elmfat format filesystem */
    if(dfs_mkfs("elm", FS_PARTITION_NAME) == 0)
        rt_kprintf("make elmfat filesystem success.\n");


    /* mount elmfat file system to FS_PARTITION_NAME */
    if(dfs_mount(FS_PARTITION_NAME, "/", "elm", 0, 0) == 0)
        rt_kprintf("elmfat filesystem mount success.\n");


    /* Get elmfat file system statistics */
    if(statfs("/", &elm_stat) == 0)
        rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n", 
                    elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);


    if(mkdir("/user", 0x777) == 0)
        rt_kprintf("make a directory: '/user'.\n");


    rt_kprintf("Write string '%s' to /user/test.txt.\n", str);


    /* Open the file in create and read-write mode, create the file if it does not exist*/
    fd = open("/user/test.txt", O_WRONLY | O_CREAT);
    if (fd >= 0)
    {
        if(write(fd, str, sizeof(str)) == sizeof(str))
            rt_kprintf("Write data done.\n");


        close(fd);   
    }


    /* Open file in read-only mode */
    fd = open("/user/test.txt", O_RDONLY);
    if (fd >= 0)
    {
        size = read(fd, buf, sizeof(buf));


        close(fd);


        if(size == sizeof(str))
            rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
    }
}
MSH_CMD_EXPORT_ALIAS(fal_elmfat_sample, fal_elmfat,fal elmfat sample);


static void easyflash_sample(void)
{
    /* fal init */
    fal_init();


    /* easyflash init */
    if(easyflash_init() == EF_NO_ERR)
    {
        uint32_t i_boot_times = NULL;
        char *c_old_boot_times, c_new_boot_times[11] = {0};


        /* get the boot count number from Env */
        c_old_boot_times = ef_get_env("boot_times");
        /* get the boot count number failed */
        if (c_old_boot_times == RT_NULL)
            c_old_boot_times[0] = '0';


        i_boot_times = atol(c_old_boot_times);
        /* boot count +1 */
        i_boot_times ++;
        rt_kprintf("===============================================\n");
        rt_kprintf("The system now boot %d times\n", i_boot_times);
        rt_kprintf("===============================================\n");
        /* interger to string */
        sprintf(c_new_boot_times, "%d", i_boot_times);
        /* set and store the boot count number to Env */
        ef_set_env("boot_times", c_new_boot_times);
        ef_save_env();
    }
}
MSH_CMD_EXPORT(easyflash_sample, easyflash sample);

3.5

测试结果

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

msh />easyflash_sample

第一次命令调用：

32842d617bc0585edaff437698408448.png

第二次RESET开发板后调用：

be4034cdb390ef5d6996ca07f51908d5.png

——————End——————

4c2153fba08fdd005d1d420914f6d232.jpeg

6de33ef30b44803558ac6bcace7d41dd.gif

想要在RT-Thread平台或社区投放内容？或想参与相关直播活动及赛事？RT-Thread已开放对接窗口，请通过邮件与我们取得联系，期待合作！

合作邮箱: tongfangyi@rt-thread.com 

RT-Thread物联网操作系统
关注
IOT-OS之RT-Thread（十一）--- FAL分区管理与easyflash变量管理
流云
10-24 1万+
FAL (Flash Abstraction Layer) Flash 抽象层，是对 Flash 及基于 Flash 的分区进行管理、操作的抽象层，对上层统一了 Flash 及 分区操作的 API。 FAL抽象层位于SFUD框架的上层，可以将多个Flash硬件（包括片内Flash和片外Flash）统一进行管理，并向上层比如DFS文件系统层提供对底层多个Flash硬件的统一访问接口，方便上层应用对底层硬件的访问操作。
RT-Thread完整版fal及easyflash移植
弓长于水的博客
03-19 2712
最近深圳开始隔离了，居家办公对于我们这种需要做验证仿真的，而家伙都没在手上的打工人太难了。因为最近项目需要用到fal加easyflash软件包，而之前搞过，但是忘记具体的了。还好留有文档，现在也转为文章吧。现在是真的体会到了学了东西没做记录等于白学是什么意思了。 （该移植操作基于stm32f103系列RT-Thread3.1.3） 环境：Keil5，ENV工具，STM32F103VET6，STM32CubeMX，stm32f103_hal_1.7.0 只要会制作BSP模板，都可以根据本文进行移植，同时博
【LPC55s69】使用FAL分区管理与easyflash变量管理
以放的博客
04-23 1437
支持静态可配置的分区表，并可关联多个 Flash 设备；分区表支持自动装载。避免在多固件项目，分区表被多次定义的问题；代码精简，对操作系统无依赖，可运行于裸机平台，比如对资源有一定要求的 Bootloader；统一的操作接口。EasyFlash） 等对 Flash 有一定依赖的组件，底层 Flash 驱动的可重用性；自带基于 Finsh/MSH 的测试命令，可以通过 Shell 按字节寻址的方式操作（读写擦） Flash 或分区，方便开发者进行调试、测试；
RT-Thread—FAL与EasyFlash组件移植
鸿蕊瑞琳
05-29 1635
一、FAL管理与示例   FAL (Flash Abstraction Layer) Flash 抽象层，是对 Flash 及基于 Flash 的分区进行管理、操作的抽象层，对上层统一了 Flash 及 分区操作的 API ，FAL 框架图如下：   从上图可以看出FAL抽象层位于SFUD框架的上层，可以将多个Flash硬件（包括片内Flash和片外Flash）统一进行管理，并向上层比如DFS文件系统层提供对底层多个Flash硬件的统一访问接口，方便上层应用对底层
stm32f103的 RT-Thread3.1.3移植SFUD+FAL+EasyFlash
弓长于水的博客
08-25 2187
学习了有两个星期的RTThread了，有些组件的移植操作还有有必要进行一下记录，1是为自己的学习过程进行记录，2是分享给大家便于大家解决问题，本文记录的就是移植SFUD+FAL+EasyFlash的操作过程，绝对的详细。 本人声明，操作都是本人移植操作，非转载文章，根据本文移植过程出现的问题可以尝试联系博主，感谢支持 环境：Keil5，ENV工具，STM32F103VET6，STM32CubeMX，stm32f103_hal_1.7.0 只要会制作BSP模板，都可以根据本文进行移植，同时博主也发过制
基于RT-Thread Studio的FAL，EasyFlash，文件系统移植
weixin_43745583的博客
12-02 2434
一、新建工程 ​ 1.2、配置时钟 1.3、修改main文件 #include <rtthread.h> #include <rtdevice.h> #include <board.h> #define DBG_TAG "main" #define DBG_LVL DBG_LOG #include <rtdbg.h> #define LED0 GET_PIN(C, 3) int main(void) { int count = 1;
STM32CubeMx开发之路—移植easyflash
iot小胡的博客
01-17 6361
STM32CubeMx开发之路—移植easyflash 运行环境 Windows10 STM32CubeMX Version 5.4.0 Keil5(MDK5) Version 5.28.0.0 硬件开发板 F103RB-NUCLEO 简介 本例程主要讲解如何移植easyflash. STM32CubeMx基本配置 基础配置过程请参考 STM32CubeMx开发之路—配置第一个项目 使...
RT-Thread Studio中外置SPI Flash和EasyFlash软件包的使用
songxunwen的博客
11-19 2499
文章目录1.新建工程2.配置CubeMX Settings，启用SPI33.打开SFUD功能并添加FAL和EasyFlash软件包4.修改FAL接口文件并初始化SFUD和FAL5.调整FAL分区结构6.修改EasyFlash接口文件并初始化Easyflash7.编译下载程序并调试功能 1.新建工程 打开RT-Thread Studio，文件-新建-RT-Thread项目，选择好芯片型号，我这里用的是STM32F405RG，设置控制台串口并命名工程后点击完成，自动生成工程。 2.配置CubeMX Settin
RT-thread应用讲解——easyflash
ShenZhen_zixian的博客
10-20 4510
在实际的应用中，我们经常需要使用片外flash来保存一些数据，比如设备的一些配置参数，但是如果每个数据都按固定地址和长度读写，就要先把所有数据的地址和长度都分配好，数据量大的话使用起来就很不方便，所以我们需要一个内存管理的应用。 easyflash是一款开源的轻量级嵌入式flash存储器库，方便开发者更加轻松的实现基于flash存储器的常见应用开发。
STM32 使用RT Studio 移植 片内flash+片上flash + sfud + fal + easyflash
03-17
本文主要讲解如何在STM32微控制器上使用RT-Thread Studio进行片内和片上Flash的移植，并结合sfud、fal和easyflash库实现高效的数据存储管理。STM32是意法半导体公司推出的基于ARM Cortex-M系列的微控制器，广泛应用...
基于国民技术芯片N452，实现SPI FLASH +FAL+FATFS+EASYFLASH+FLASHDB 移植OK
03-18
使用文件系统可以读取SPI FLASH，整合开源软件EASY FLASH ,FLASHDB 统一到一个应用工程下面，完美实现文件存储，BOOT升级，数据记录，日志记录等相关功能，目前实现的是一个最小系统，文件读写按照12K BYTE进行测试...
STM32F407的HAL库移植EasyFlash、FAL、SFUD详细说明手把手教你如何移植、学习、验证
09-04
手把手教你基于STM32F407芯片，使用HAL库开发Easy... 使用 EasyFlash 就必须挂载 Flash，而挂载 Flash 是通过 FAL 组件进行分区管理，FAL 是对不同的 Flash 设备做出抽象的接口，可以分区管理、读写且支持多块 Flash。
MySQL【知识改变命运】03
2402_84062064的博客
10-07 1594
表的创建
MySQL表的增删改查(基础)
weixin_63965017的博客
10-02 706
语法表名values(值，值......);值与列相匹配。
Mysql（索引与事务）
qq_63074244的博客
10-02 823
在早些年代会出现，A给B转了钱而B却并未收到，因此引入了事务中的回滚（指的是通过检查若没有执行成功就回退回去，比如A给B转了钱而B却并未收到时，那么就会触发回滚把A转出金额再返回给A）来解决这一问题。事务是把多个SQL打包成为一个整体，要么都执行，要么做到看起来都不执行的样子。原子性：保证一系列操作都能正确执行或者恢复如初一致性：事务执行之前之后，数据都不能太离谱持久性：事务做出的修改，都是在硬盘上持久保存的。服务器重启数据依然存在隔离性：解决数据库处理并非事务中出现的问题。
基于微信小程序的生鲜订购小程序系统(SpringBoot+Vue+Uniapp+MySQL)
源码好优多
10-06 1860
开发者不再需要手动配置大量的 XML 文件或繁琐的注解，框架提供了默认的配置，根据项目的依赖关系和约定，自动完成配置。系统测试主要是为了避免用户在使用时发生问题，增强用户体验感，为了不影响用户的使用，我们需要从多角度、多思路去考虑系统可能遇到的问题，通过不同的模拟场景来发现缺陷并解决问题。添加用户时，必填项不填，检验系统是否有非空检验；登录功能测试方案：当需要登入该系统时，通过账户密码等功能点进行验证，用户在输入时需要输入与数据库内存储的数据匹配的内容，当其中某项输入错误时系统将提示输入错误。
mysql
最新发布
mnwl12_0的博客
10-09 920
事先经过编译并存储在数据库中的一段 SQL语句的集合，调用存储过程可以简化应用开发人员的很多工作，减少数据在数据库和应用服务器之间的传输，对于提高数据处理的效率是有好处的。对视图进行增删改本质上就是对基表的修改，视图并不存储数据，当使用WITH CHECK OPTION子句创建视图时，MySQL会通过视图检查正在更改的每个行，例如 插入，更新，删除，以使其符合视图的定义。第二层架构主要完成大多数的核心服务功能，如SQL接口，并完成缓存的查询，SQL的分析和优化，部分内置函数的执行。
【MySQL】多表联合查询常见练习题
weixin_71491685的博客
10-02 889
- 各科成绩最高分、最低分和平均分。-- 及格率，中等率，优良率，优秀率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值