RT-Thread Studio STM32F249BIT6片内FLASH移植FAL记录

最新推荐文章于 2024-04-29 10:06:44 发布
最新推荐文章于 2024-04-29 10:06:44 发布
阅读量1k 收藏 4
点赞数
分类专栏： RTthread 物联网 文章标签： stm32 arm 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a200327/article/details/122416860
版权

RT-Thread Studio STM32F249BIT6移植FAL记录

刚好需要使用到操作内部flash，发现FAL这个很不错，移植过程遇到一些小bug，故此记录一下。

我使用的是STM32F429BIT6 内部有2M的flash和网上大部分人不一样。

1.先增加软件包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-42yEQLN0-1641811651714)(https://os.zhengshijian.com//img/image-20220110183319490.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BZSFjp4G-1641811651716)(https://os.zhengshijian.com//img/image-20220110183309722.png)]

在rtt studio没找到flash的地方，直接再board.h中增加宏来打开
在这里插入图片描述

2.增加port文件

image-20220110183409700

下面是这两个文件的代码

h文件

/*
 * File      : fal_cfg.h
 * This file is part of FAL (Flash Abstraction Layer) package
 * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2018-05-17     armink       the first version
 */

#ifndef _FAL_CFG_H_
#define _FAL_CFG_H_

#include <rtconfig.h>
#include <board.h>


/* ===================== Flash device Configuration ========================= */
extern const struct fal_flash_dev stm32f4_onchip_flash;

/* flash device table */
#define FAL_FLASH_DEV_TABLE                                          \
{                                                                    \
    &stm32f4_onchip_flash,                                           \
}
/* ====================== Partition Configuration ========================== */
#ifdef FAL_PART_HAS_TABLE_CFG
/* partition table */
#define FAL_PART_TABLE                                                                  \
{                                                                                       \
    {FAL_PART_MAGIC_WORD,        "bl",      "stm32f4_onchip",         0,  128*1024,   0}, \
    {FAL_PART_MAGIC_WORD,       "app1",     "stm32f4_onchip",   0x20000,  7*128*1024, 0}, \
    {FAL_PART_MAGIC_WORD,        "arg",     "stm32f4_onchip",  0x100000,  128*1024,   0}, \
    {FAL_PART_MAGIC_WORD,       "app2",     "stm32f4_onchip",  0x120000,  7*128*1024, 0}, \
}
#endif /* FAL_PART_HAS_TABLE_CFG */

#endif /* _FAL_CFG_H_ */

c文件

/*
 * File      : fal_flash_stm32f4_port.c
 * This file is part of FAL (Flash Abstraction Layer) package
 * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2018-01-26     armink       the first version
 */

#include <fal.h>

#include <stm32f4xx.h>

#define DBG_TAG "fal_flash_port"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

/* base address of the flash sectors */
#define ADDR_FLASH_SECTOR_0      ((uint32_t)0x08000000) /* Base address of Sector 0, 16 K bytes   */
#define ADDR_FLASH_SECTOR_1      ((uint32_t)0x08004000) /* Base address of Sector 1, 16 K bytes   */
#define ADDR_FLASH_SECTOR_2      ((uint32_t)0x08008000) /* Base address of Sector 2, 16 K bytes   */
#define ADDR_FLASH_SECTOR_3      ((uint32_t)0x0800C000) /* Base address of Sector 3, 16 K bytes   */
#define ADDR_FLASH_SECTOR_4      ((uint32_t)0x08010000) /* Base address of Sector 4, 64 K bytes   */
#define ADDR_FLASH_SECTOR_5      ((uint32_t)0x08020000) /* Base address of Sector 5, 128 K bytes  */
#define ADDR_FLASH_SECTOR_6      ((uint32_t)0x08040000) /* Base address of Sector 6, 128 K bytes  */
#define ADDR_FLASH_SECTOR_7      ((uint32_t)0x08060000) /* Base address of Sector 7, 128 K bytes  */
#define ADDR_FLASH_SECTOR_8      ((uint32_t)0x08080000) /* Base address of Sector 8, 128 K bytes  */
#define ADDR_FLASH_SECTOR_9      ((uint32_t)0x080A0000) /* Base address of Sector 9, 128 K bytes  */
#define ADDR_FLASH_SECTOR_10     ((uint32_t)0x080C0000) /* Base address of Sector 10, 128 K bytes */
#define ADDR_FLASH_SECTOR_11     ((uint32_t)0x080E0000) /* Base address of Sector 11, 128 K bytes */

#define ADDR_FLASH_SECTOR_12      ((uint32_t)0x08100000) /* Base address of Sector 0, 16 K bytes   */
#define ADDR_FLASH_SECTOR_13      ((uint32_t)0x08104000) /* Base address of Sector 1, 16 K bytes   */
#define ADDR_FLASH_SECTOR_14      ((uint32_t)0x08108000) /* Base address of Sector 2, 16 K bytes   */
#define ADDR_FLASH_SECTOR_15      ((uint32_t)0x0810C000) /* Base address of Sector 3, 16 K bytes   */
#define ADDR_FLASH_SECTOR_16      ((uint32_t)0x08110000) /* Base address of Sector 4, 64 K bytes   */
#define ADDR_FLASH_SECTOR_17      ((uint32_t)0x08120000) /* Base address of Sector 5, 128 K bytes  */
#define ADDR_FLASH_SECTOR_18      ((uint32_t)0x08140000) /* Base address of Sector 6, 128 K bytes  */
#define ADDR_FLASH_SECTOR_19      ((uint32_t)0x08160000) /* Base address of Sector 7, 128 K bytes  */
#define ADDR_FLASH_SECTOR_20      ((uint32_t)0x08180000) /* Base address of Sector 8, 128 K bytes  */
#define ADDR_FLASH_SECTOR_21      ((uint32_t)0x081A0000) /* Base address of Sector 9, 128 K bytes  */
#define ADDR_FLASH_SECTOR_22      ((uint32_t)0x081C0000) /* Base address of Sector 10, 128 K bytes */
#define ADDR_FLASH_SECTOR_23      ((uint32_t)0x081E0000) /* Base address of Sector 11, 128 K bytes */

/**
 * Get the sector of a given address
 *
 * @param address flash address
 *
 * @return The sector of a given address
 */
static uint32_t stm32_get_sector(uint32_t address)
{
    uint32_t sector = 0;

    if ((address < ADDR_FLASH_SECTOR_1) && (address >= ADDR_FLASH_SECTOR_0))
    {
        sector = FLASH_SECTOR_0;
    }
    else if ((address < ADDR_FLASH_SECTOR_2) && (address >= ADDR_FLASH_SECTOR_1))
    {
        sector = FLASH_SECTOR_1;
    }
    else if ((address < ADDR_FLASH_SECTOR_3) && (address >= ADDR_FLASH_SECTOR_2))
    {
        sector = FLASH_SECTOR_2;
    }
    else if ((address < ADDR_FLASH_SECTOR_4) && (address >= ADDR_FLASH_SECTOR_3))
    {
        sector = FLASH_SECTOR_3;
    }
    else if ((address < ADDR_FLASH_SECTOR_5) && (address >= ADDR_FLASH_SECTOR_4))
    {
        sector = FLASH_SECTOR_4;
    }
    else if ((address < ADDR_FLASH_SECTOR_6) && (address >= ADDR_FLASH_SECTOR_5))
    {
        sector = FLASH_SECTOR_5;
    }
    else if ((address < ADDR_FLASH_SECTOR_7) && (address >= ADDR_FLASH_SECTOR_6))
    {
        sector = FLASH_SECTOR_6;
    }
    else if ((address < ADDR_FLASH_SECTOR_8) && (address >= ADDR_FLASH_SECTOR_7))
    {
        sector = FLASH_SECTOR_7;
    }
    else if ((address < ADDR_FLASH_SECTOR_9) && (address >= ADDR_FLASH_SECTOR_8))
    {
        sector = FLASH_SECTOR_8;
    }
    else if ((address < ADDR_FLASH_SECTOR_10) && (address >= ADDR_FLASH_SECTOR_9))
    {
        sector = FLASH_SECTOR_9;
    }
    else if ((address < ADDR_FLASH_SECTOR_11) && (address >= ADDR_FLASH_SECTOR_10))
    {
        sector = FLASH_SECTOR_10;
    }else if ((address < ADDR_FLASH_SECTOR_12) && (address >= ADDR_FLASH_SECTOR_11)){
        sector = FLASH_SECTOR_11;
    }
    else if ((address < ADDR_FLASH_SECTOR_13) && (address >= ADDR_FLASH_SECTOR_12))
    {
        sector = FLASH_SECTOR_12;
    }
    else if ((address < ADDR_FLASH_SECTOR_14) && (address >= ADDR_FLASH_SECTOR_13))
    {
        sector = FLASH_SECTOR_13;
    }
    else if ((address < ADDR_FLASH_SECTOR_15) && (address >= ADDR_FLASH_SECTOR_14))
    {
        sector = FLASH_SECTOR_14;
    }
    else if ((address < ADDR_FLASH_SECTOR_16) && (address >= ADDR_FLASH_SECTOR_15))
    {
        sector = FLASH_SECTOR_15;
    }
    else if ((address < ADDR_FLASH_SECTOR_17) && (address >= ADDR_FLASH_SECTOR_16))
    {
        sector = FLASH_SECTOR_16;
    }
    else if ((address < ADDR_FLASH_SECTOR_18) && (address >= ADDR_FLASH_SECTOR_17))
    {
        sector = FLASH_SECTOR_17;
    }
    else if ((address < ADDR_FLASH_SECTOR_19) && (address >= ADDR_FLASH_SECTOR_18))
    {
        sector = FLASH_SECTOR_18;
    }
    else if ((address < ADDR_FLASH_SECTOR_20) && (address >= ADDR_FLASH_SECTOR_19))
    {
        sector = FLASH_SECTOR_19;
    }
    else if ((address < ADDR_FLASH_SECTOR_21) && (address >= ADDR_FLASH_SECTOR_20))
    {
        sector = FLASH_SECTOR_20;
    }else if ((address < ADDR_FLASH_SECTOR_22) && (address >= ADDR_FLASH_SECTOR_21))
    {
        sector = FLASH_SECTOR_21;
    }
    else if ((address < ADDR_FLASH_SECTOR_23) && (address >= ADDR_FLASH_SECTOR_22))
    {
        sector = FLASH_SECTOR_22;
    }else {
        sector = FLASH_SECTOR_23;
    }

    return sector;
}

/**
 * Get the sector size
 *
 * @param sector sector
 *
 * @return sector size
 */
static uint32_t stm32_get_sector_size(uint32_t sector) {
    assert(IS_FLASH_SECTOR(sector));

    switch (sector) {
    case FLASH_SECTOR_0: return 16 * 1024;
    case FLASH_SECTOR_1: return 16 * 1024;
    case FLASH_SECTOR_2: return 16 * 1024;
    case FLASH_SECTOR_3: return 16 * 1024;
    case FLASH_SECTOR_4: return 64 * 1024;
    case FLASH_SECTOR_5: return 128 * 1024;
    case FLASH_SECTOR_6: return 128 * 1024;
    case FLASH_SECTOR_7: return 128 * 1024;
    case FLASH_SECTOR_8: return 128 * 1024;
    case FLASH_SECTOR_9: return 128 * 1024;
    case FLASH_SECTOR_10: return 128 * 1024;
    case FLASH_SECTOR_11: return 128 * 1024;

    case FLASH_SECTOR_12: return 16 * 1024;
    case FLASH_SECTOR_13: return 16 * 1024;
    case FLASH_SECTOR_14: return 16 * 1024;
    case FLASH_SECTOR_15: return 16 * 1024;
    case FLASH_SECTOR_16: return 64 * 1024;
    case FLASH_SECTOR_17: return 128 * 1024;
    case FLASH_SECTOR_18: return 128 * 1024;
    case FLASH_SECTOR_19: return 128 * 1024;
    case FLASH_SECTOR_20: return 128 * 1024;
    case FLASH_SECTOR_21: return 128 * 1024;
    case FLASH_SECTOR_22: return 128 * 1024;
    case FLASH_SECTOR_23: return 128 * 1024;

    default : return 128 * 1024;
    }
}
static int init(void)
{
    /* do nothing now */
}

static int read(long offset, uint8_t *buf, size_t size)
{
    size_t i;
    uint32_t addr = stm32f4_onchip_flash.addr + offset;

    if ((addr + size) > STM32_FLASH_END_ADDRESS)
    {
        LOG_E("read outrange flash size! addr is (0x%p)", (void*)(addr + size));
        return -1;
    }

    for (i = 0; i < size; i++, addr++, buf++)
    {
        *buf = *(uint8_t *) addr;
    }

    return size;
}

static int write(long offset, const uint8_t *buf, size_t size)
{
    size_t i;
    rt_err_t result      = RT_EOK;
    uint32_t read_data;
    uint32_t addr = stm32f4_onchip_flash.addr + offset;
    uint32_t end_addr = addr + size;

    if ((end_addr) > STM32_FLASH_END_ADDRESS)
    {
        LOG_E("write outrange flash size! addr is (0x%p)", (void*)(addr + size));
        return -RT_EINVAL;
    }

    if (size < 1)
    {
        return -RT_EINVAL;
    }

    HAL_FLASH_Unlock();

    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

    for (size_t i = 0; i < size; i++, addr++, buf++)
    {
        /* write data to flash */
        if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, addr, (rt_uint64_t)(*buf)) == HAL_OK)
        {
            if (*(rt_uint8_t *)addr != *buf)
            {
                result = -RT_ERROR;
                break;
            }
        }
        else
        {
            result = -RT_ERROR;
            break;
        }
    }

    HAL_FLASH_Lock();

    if (result != RT_EOK)
    {
        return result;
    }

    return size;
}

static int erase(long offset, size_t size)
{
    uint32_t addr = stm32f4_onchip_flash.addr + offset;

    rt_err_t result = RT_EOK;
    rt_uint32_t FirstSector = 0, NbOfSectors = 0;
    rt_uint32_t SECTORError = 0;

    if ((addr + size) > STM32_FLASH_END_ADDRESS)
    {
        LOG_E("ERROR: erase outrange flash size! addr is (0x%p)\n", (void*)(addr + size));
        return -RT_EINVAL;
    }

    /*Variable used for Erase procedure*/
    FLASH_EraseInitTypeDef EraseInitStruct;

    /* Unlock the Flash to enable the flash control register access */
    HAL_FLASH_Unlock();

    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

    /* Get the 1st sector to erase */
    FirstSector = stm32_get_sector(addr);
    /* Get the number of sector to erase from 1st sector*/
    NbOfSectors = stm32_get_sector(addr + size - 1) - FirstSector + 1;
    /* Fill EraseInit structure*/
    EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    EraseInitStruct.Sector        = FirstSector;
    EraseInitStruct.NbSectors     = NbOfSectors;

    if (HAL_FLASHEx_Erase(&EraseInitStruct, (uint32_t *)&SECTORError) != HAL_OK)
    {
        result = -RT_ERROR;
        goto __exit;
    }

__exit:
    HAL_FLASH_Lock();

    if (result != RT_EOK)
    {
        return result;
    }

    LOG_D("erase done: addr (0x%p), size %d", (void*)addr, size);
    return size;

}

static int stm32_flash_init(void)
{
    /* doing nothing now */
}

const struct fal_flash_dev stm32f4_onchip_flash =
{
    .name       = "stm32f4_onchip",
    .addr       = 0x08000000,  // Flash start address
    .len        = 2*1024*1024, //stm32f429bit6 2M Flash
    .blk_size   = 128*1024,    //largest sector size
    //.ops        = {stm32_flash_init, stm32_flash_read, stm32_flash_write, stm32_flash_erase},
    .ops        = {stm32_flash_init, read, write, erase},
    .write_gran = 8
};

3.命令行测试

首先需要先在主函数初始化

image-20220110183937740

下面使用的是msh测试，没有代码测试。

image-20220110184058701

注意点：

  1. 分区表的flash设备名要和fal_flash_dev中定义的名称一致
  2. 我没有用rtthread里的drv_flash_f4.c的函数，最开始用这个出错了，被我改掉了。

image-20220110183652442他这里用的是3个dev，每个dev地址还要自己配置，我这个是2个bank的flash，跟普通的不一样，所以得自己写。应该就是地址出错了，所以用他的flash读写擦函数出错了。
很多教程都是多个dev设备，我这里直接用了单一个dev，然后多个分区表基于这个dev。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMbGBpbc-1641811651717)(https://os.zhengshijian.com//img/image-20220110183842189.png)]

好了，FAL弄好了，统一了操作接口，OTA就好弄了，后面如果改到外部SPI FLASH也极其方便，现在这个2M Flash够我用，所以也就不弄外部SPI FLASH了。

炒饭多加个蛋
关注
专栏目录
stm32 通用bootloader_使用RT-Thread Studio移植RT-Thread & 制作STM32通用BootLoader
weixin_39830225的博客
12-20 716
主控：STM32F407VET6环境：RT-Thread Studio ,STM32CubeMX, ENV，RT-Thread v.4.0.2概述：通过Studio创建芯片对应的内核工程，添加软件包，修改配置文件，在线生成对应的RT-Boot，实现OTA固件升级一. 创建RT-Thread内核工程根据自己的芯片和外设创建RTT内核工程进入工程后，查看RT-Thread Setting ,可以发现串...
RT-Thread Studio片上Flash 实现Flash抽象层FAL笔记
01-06
使用ATK-NANO STM32F411的开发板， 实现Flash抽象层FAL。 先添加fal的软件包，并复制fal_cfg.h到drivers目录下： 复制C:\RT-ThreadStudio\download\rt-thread-sdk\rt-thread-src\v4.0.2\bsp\stm32\libraries\HAL_Drivers\drv_flash目录下的drv_flash.h文件和对应的flash驱动文件如drv_flash_f4.c到drivers目录下，复制上一级目录的drv_log.h到drivers目录下，并注释drv_flash_f4.c文件中的#include
RT-Thread——STM32——FAL库
iot小胡的博客
08-13 3582
RT-Thread——STM32——FAL库 概述 本教程主要根据官方推荐的教程进行改编，详细信息请参考FAL软件包 本例程的模板使用通用模板环境搭建里面的模板RT-Thread——STM32——环境搭建 文末也有我一直好的例程，不过建议大家从头开始移植，加深印象^_^ 配置 打开board目录下的Kconfig文件 因为FAL需要Flash支持，所以要添加如下代码 config B...
rt thread 使用FAL遇到fal_init() undefined reference
qq_35593582的博客
06-02 665
遇到一个坑，填一下 rt thread FAL 0.5版，之前有没有不知道，遇到一个坑 在main.cpp里面已经 #include <fal.h> 在下面调用 fal_init()
FAL：Flash 抽象层的使用
郁金香
07-04 1080
FAL (Flash Abstraction Layer) Flash 抽象层，是对 Flash 及基于 Flash 的分区进行管理、操作的抽象层，对上层统一了 Flash 及 分区操作的 API
FAL移植
SammySum的博客
03-18 1237
概述 FAL (Flash Abstraction Layer) Flash 抽象层，是对 Flash 及基于 Flash 的分区进行管理、操作的抽象层，对上层统一了 Flash 及 分区操作的 API (框架图如下所示)，并具有以下特性： 支持静态可配置的分区表，并可关联多个 Flash 设备； 分区表支持 自动装载 。避免在多固件项目，分区表被多次定义的问题； 代码精简，对操作系统 无依赖 ，可运行于裸机平台，比如对资源有一定要求的 Bootloader； 统一的操作接口。保证了文件系统、OTA、NV
STM32L496使用EasyFlash完成KV参数存储【RT-Thread工程，支持STM32L4系列单片机】.zip
05-16
本项目着重讲解如何在基于RT-Thread实时操作系统的环境中，利用EasyFlash库来实现关键参数（KV参数）的非易失性存储，尤其适用于STM32L4系列单片机。 RT-Thread是一个开源、轻量级的实时操作系统，提供丰富的组件和...
STM32 使用RT Studio 移植 片内flash+片上flash + sfud + fal + easyflash
03-17
本文主要讲解如何在STM32微控制器上使用RT-Thread Studio进行片内和片上Flash的移植，并结合sfud、fal和easyflash库实现高效的数据存储管理。STM32是意法半导体公司推出的基于ARM Cortex-M系列的微控制器，广泛应用...
STM32F407的HAL库移植EasyFlash、FAL、SFUD详细说明手把手教你如何移植、学习、验证
最新发布
09-04
手把手教你基于STM32F407芯片，使用HAL库开发EasyFlash轻量级嵌入式 flash 存储器库，分别添加内部Flash、片外Flash作为存储空间，文档详细说明了修改内容对比。 使用 EasyFlash 就必须挂载 Flash，而挂载 Flash 是...
STM32通用FLASH管理软件包——SFUD/FAL
sinat_31039061的博客
06-02 4081
本次介绍的三个软件包SFUD/FAL/EASYFLASH都与FLASH有关，并且都可以独立使用或者结合在一起使用，三个软件包都可以使用裸机移植，也很方便移植到各种系统。 这三个软件包的作者都是armink，armink的开源仓库地址：https://github.com/armink，更多好玩的软件，请到作者仓库查询。 以下将结合rtthread系统，分别对这三个软件包做下演示。 SFUD SFUD 是一款开源的串行 SPI Flash 通用驱动库。由于现有市面的串行 Flash 种类居多，各个 Flash
STM32F7 使用 FAL 配置片上FLASH
qq_39665253的博客
03-30 625
使用STM32F767芯片 加载RTT 3.15完整版，采用ENV工具，用KEIL加载工程，使用FAL配置片上FLASH，采用ARMV6编译器 优化等级-0 工程BSP目录下运行env 输入menuconfig进入菜单 USER DRIVer CONFIG 是我自己编写的，没有用 从截图所示进入 使能 on-chip FLASH 从截图所示进入 按空格使能，按回车进入配置。如截图所示进行配置 进行保存 使用SCONS命令 无修改进行编译运行，有三个..
RT_Thread_使用FAL组件配置stm32f407片上flash读写
人非生而知之者
12-07 1360
先看下struct fal_flash_dev的具体成员，有flash设备名字、flash起始地址、flash大小、块大小（执行擦除时的最小颗粒）、操作函数（init、read、write、erase）、写操作最小颗粒度；size_t len;第一部分：宏定义各扇区的起始地址第二部分：读、写、擦除第三部分：使用了FAL之后的FLASH设备定义以及对于的读、写、擦除操作函数。
stm32f407使用rt thread 的easy flash 和fal
qq_35593582的博客
06-03 3146
昨天调了一下fal，初步把easy flash给编译进去了，然后再记录一下几个坑。 easyflash的官方文档其实说的有点不明不白的，我把几个guan'jian'dian
RT-thread应用讲解——FLASH分区
ShenZhen_zixian的博客
10-15 4906
因为单片机的存储比较小，所以我们经常会用到外置FLASH来存储一些文件、数据或者OTA等。如果一个FLASH只用来做单一的功能，那只需要把所有内存都分配到这个功能上就行了，但是如果要用一个FLASH同时做多个功能，比如我用一部分内存来做文件系统，一部分用来存OTA升级固件，那在操作内存的时候就要注意地址的分配了，为了方便内存管理，我们通常会进行分区处理。 RT-thread系统就有分区和内存管理相关的软件包，这一点还是很方便的。
rtthread studio与正点原子apollo(13)--QSPI设备之flash存储器
hfh8130的博客
09-26 736
rtthread；qspi
RT-Thread Studio 使用STM32CubeMX联合开发——基于SPI通信，SFUD驱动，FAL组件使用W25Q32
Troubadour~的博客
04-29 883
本文为Studio 使用STM32CubeMX联合开发中——基于SPI通信，SFUD驱动，FAL组件使用W25Q32的读写。先看层级关系。
在RT-Thread Studio配置Onchip Flash littlefs文件系统
aping_cs_dn的专栏
02-06 457
STM32片上flash文件系统挂载时踩过的坑，记录下来于您分享！
STM32G473VET6 FlashDB数据库移植（裸机、片内Flash）
qq_17833651的博客
07-25 1997
此文档也适用于STM32G070。
RT-Thread 使用FAL多字节读写FLASH
Nuko的博客
10-14 3989
RT-Thread 使用FAL跨页多字节读写SPI FLASHFAL 简介在RT-Thread上使用FAL添加SPI 总线驱动添加SFUD驱动添加SPI DEVICE使用SFUD添加SPI 块设备添加FAL添加fal_nbyte验证 FAL 简介 FAL (Flash Abstraction Layer) Flash 抽象层，是 RT-Thread 的一个软件包，是对 Flash 及基于 Flash的分区进行管理、操作的抽象层，对上层统一了 Flash 及分区操作的 API ，并具有以下特性： • 支持静态
STM32F411开发板实现RT-Thread FAL笔记
"这篇笔记介绍了如何在RT-Thread Studio环境下，针对STM32F411的ATK-NANO开发板实现Flash抽象层（FAL）的配置与使用。主要涉及了添加FAL软件包、配置相关头文件及驱动文件的过程。" 在RT-Thread操作系统中，Flash...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

炒饭多加个蛋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值