基于flash的快速缓存（ringbuffer）设计，掉电恢复，擦除平衡。

最新推荐文章于 2024-05-03 15:20:53 发布
最新推荐文章于 2024-05-03 15:20:53 发布
阅读量1.1k 收藏 3
点赞数 3
文章标签： flash ringbuffer 掉电恢复
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_31980479/article/details/80018348
版权

先讲讲本次主题的项目需求：

1、透传数据，若无连接则必须缓存数据（数据上传的环境很不理想，很可能1周后才有人处理）。

2、最差情况：缓存百兆字节数据;

2、缓存的数据按先进先出顺序;

3、缓存数据接收每次100～4K字节，每段数据总长度10K～1M不等。

4、stm32平台64K内存，64KROM;（由于USB Host驱动，再加上系统及任务本身耗费，内存裕量约40k）;

设计方案：

首先，开发版采用的是NOR flash， 其擦写寿命约为10w次。如果采用fat文件系统的话，因为每次追加数据很少，那么势必频繁更新目录项与fat表。那么flash上这块区域根本坚持不了多久（粗略估计1年）就坏了。并且fat文件系统是非常古老的系统，抗掉电，各种健壮性都很差。所幸早已有专用于flash的文件系统如JFFS2。

但是JFFS2也有其缺点：1、发现该文件系统占用的内存随flash的大小增大，如果是256Mflash，需要的内存已经超出了本次项目需求。2、文件系统加载时间也是随flash的大小增大（达到几分钟级别），所以不是很适用本次项目。

因而本项目决定采用了ringbuffer方式，根据flash的擦除特性，并吸收JFFS2的一些优点来完善掉电恢复，写平衡，擦除平衡。延长寿命。

jffs2的mask方法，不同的文件类型不同的type。同样采用结构体进行辨别控制：

struct fs_dir{

uint16_t magic;

uint16_t type;

uint16_t ino;

......

uint16 hcrc;

};

讲解：

       为了达到快速遍历重新恢复上次掉电前状态，同时为了免除删除数据和不删除数据在同一个擦除块，而进行搬运数据。缓存数据以擦除块大小（假设4k）为单位进行保存。每个缓存数据块（第一页page，保存目录项等数据，称为目录页）。这样只需对4k字节对齐地址进行扫描即可重建快速定位了。为了更快的进行加载，目录页中，可在添加文件小结数据，指出其大小，占用空间等。同理文件的删除亦可以放在目录页（删除存在的原因是为了下次加载时，识别出这是无效数据）。

       另外为了防止擦除到一半意外停止了，也学习JFFS2，在擦除完成后加入擦除Mask。后续检查Mask即可知道是否已擦除，在检查后续两字符可知道这个块是否使用过（这里假设所有flash写入都是自己写入，都是顺序写入）。当然在数据项中包含着数据的CRC校验，以确保这个数据正常工作。

代码构思调试总共花了二周，略显粗糙，不过够用就行。话不多说上关键代码。

/*
*   easyfs's ringbuffer at flash
*
*   ebtail ->  ----------------------------------------             <---- erase block 0xXX0000 / page 0
*                   | EraseMask| Dir | DirSum | DirDel     |
*                   |                                                          |
*                    ---------------------------------------             <---- page 1 0xXXX100
*                   | Node | Data ...                                  |
*                   |  Data ...                                             |
*
*                    ..................................
*
*                    |                                                       |           <---- erase block 0xXX0FFF
*                     -------------------------------------             <---- erase block 0xXX1000 / page 16
*                    | EraseMask|  Node | Data ...           |
*
*                      ..................................
*
*  ebhdr  ---> -----------------------------------
*                    | EraseMask| 0xFF 0xFF .......           |             <---- erase block 0xXX2000 / page 16
*

*/

 int isHdrType(uint8_t type, void* buf, uint32_t maxsize)
{
    Efs_PageUnknow_t *hdr;
    uint32_t crcofs;
    uint32_t hcrc;
    uint32_t crc;
    hdr = (Efs_PageUnknow_t*)buf;
    if(hdr->magic != EFS_PAGE_MAGIC){
        //LOG(LOG_INFO, "no HDR magic: %02x %02x\n", ((char*)buf)[0], ((char*)buf)[1]);
        return 0;
    }
    if(type != hdr->type){
        if(!(type == 2 && hdr->type == 1))
            LOG(LOG_INFO, "actualy type %d(except %d)\n", hdr->type, type);
        return 0;
    }
    switch(hdr->type){
        case EFS_TYPE_ERASE:
            crcofs = offsetof(Efs_PageEraseHeader_t, hcrc);
            hcrc = ((Efs_PageEraseHeader_t*)buf)->hcrc;            
            break;
        case EFS_TYPE_NODE:
            crcofs = offsetof(Efs_PageNodeHeader_t, hcrc);
            hcrc = ((Efs_PageNodeHeader_t*)buf)->hcrc;
            break;
        case EFS_TYPE_DIR:
            crcofs = offsetof(Efs_PageDirHeader_t, hcrc);
            hcrc = ((Efs_PageDirHeader_t*)buf)->hcrc;
            break;
        case EFS_TYPE_DIRSUM:
            crcofs = offsetof(Efs_PageDirSumHeader_t, hcrc);
            hcrc = ((Efs_PageDirSumHeader_t*)buf)->hcrc;
            break;        
        case EFS_TYPE_DIRDEL:
            crcofs = offsetof(Efs_PageDirDelHeade_t, hcrc);
            hcrc = ((Efs_PageDirDelHeade_t*)buf)->hcrc;
            break;
        default:
            LOG(LOG_WARN, "efs unknow type\n");
            return 0;
    }
    if(crcofs > maxsize){
        LOG(LOG_WARN, "efs hdr crcofs large than maxsize %d\n", maxsize);
        return 0;
    }
    crc = crc32(0, buf, crcofs);
    if(crc == hcrc){
        return 1;
    }
    else{
        LOG(LOG_WARN, "efs hdr crc error: type %d crcofs %d, crc %x, hcrc %x\n", hdr->type, crcofs, crc, hcrc);
        DUMP("CRC CHECK", buf, crcofs+4);
        return 0;
    }
}


void fileStreamIn(File_Opt opt, uint8_t* buf, uint32_t size)
{
    static Efs_PageDirHeader_t dh;
    static Efs_PageDirSumHeader_t ds;
    static Efs_PageNodeHeader_t n;
    static Efs_PageDirDelHeade_t dl;

    dh.magic = EFS_PAGE_MAGIC;
    dh.type = EFS_TYPE_DIR;
    ds.magic = EFS_PAGE_MAGIC;
    ds.type = EFS_TYPE_DIRSUM;
    n.magic = EFS_PAGE_MAGIC;
    n.type = EFS_TYPE_NODE;
    dl.magic = EFS_PAGE_MAGIC;
    dl.type = EFS_TYPE_DIRDEL;    
    
    static uint32_t fileEbofs = 0;
    uint8_t* data;
    uint32_t ctlen;
    uint32_t valid_left;
    uint32_t e_offset;
    srand(HAL_GetTick());
    switch(opt){
        case File_PUSH:
            dh.id = rand();
            dh.time = highesttime + HAL_GetTick();
            dh.hcrc = crc32(0, (uint8_t*)&dh, offsetof(Efs_PageDirHeader_t, hcrc));
            fileEbofs = ebhdr;
            //write
            writeDir(&dh, ebhdr + sizeof(Efs_PageEraseHeader_t));
            //syn
            ds.id = dh.id;
            ds.tldsize = 0;
            ds.ebsize = 0;
            n.id = dh.id;
            fileEbofs = ebhdr;
            addEbHdr(PAGE_SIZE);
            if(size == 8 && buf){
                memcpy(buf, &dh.id, 4);
                memcpy(buf+4, &dh.time, 4);
            }
            break;
        case File_WRITE:
            data = buf;
            while(size){
                e_offset = ((ebhdr&0xf00)? 0:sizeof(Efs_PageEraseHeader_t));
                valid_left = EARSEBLOCK_SIZE - (ebhdr&0xf00)- e_offset - sizeof(Efs_PageNodeHeader_t);
                ctlen = size > valid_left? valid_left: size;
                n.offset = ds.tldsize;
                n.dsize = ctlen;
                n.dcrc = crc32(0, data, ctlen);
                n.hcrc = crc32(0, (uint8_t*)&n, offsetof(Efs_PageNodeHeader_t, hcrc));
                writeNode(&n, ebhdr + e_offset, data, ctlen);
                //syn
                addEbHdr(ctlen + sizeof(Efs_PageNodeHeader_t) + e_offset);

                size -= ctlen;
                data += ctlen;
                ds.tldsize += ctlen;                
            }
            
            break;
        case File_END:
            //ebhdr -> next start position
            roundEbHdr();
            ds.ebsize = (ebhdr - fileEbofs);
            ds.hcrc = crc32(0, (uint8_t*)&ds, offsetof(Efs_PageDirSumHeader_t, hcrc));
            writeDirSum(&ds, fileEbofs + sizeof(Efs_PageEraseHeader_t) + sizeof(Efs_PageDirHeader_t));
            writeflush();
            //syn
    
            break;
        case File_DEL:

            dl.id = ds.id;
            dl.hcrc = crc32(0, (uint8_t*)&dl, offsetof(Efs_PageDirDelHeade_t, hcrc));
            writeDirDel(&dl, fileEbofs + sizeof(Efs_PageEraseHeader_t) + sizeof(Efs_PageDirHeader_t) + sizeof(Efs_PageDirSumHeader_t));
            writeflush();
            //syn
            LOG(LOG_INFO, "push file del: id %x, at fileEbofs 0x%08x\n", dh.id, fileEbofs);
            break;
        default:
            break;
    }

}

int popTailFile(uint32_t *address, Efs_PageDirHeader_t *d_dh, Efs_PageDirSumHeader_t *d_ds)
{
    uint8_t *buf = (uint8_t*)readBuf;
    uint32_t bufofs;
    uint32_t ebofs = ebtail;
    
    while(1){
        if(ebofs >= ebhdr)//to the end
            return -1;

    bufofs = 0;       

 //这段可以封装，自己弄吧

        read(ebofs, buf, sizeof(Efs_PageEraseHeader_t) + sizeof(Efs_PageDirHeader_t) + sizeof(Efs_PageDirSumHeader_t) + sizeof(Efs_PageDirDelHeade_t));
        if(isHdrType(EFS_TYPE_ERASE, buf, sizeof(Efs_PageEraseHeader_t))){
            bufofs += sizeof(Efs_PageEraseHeader_t);
            if(isHdrType(EFS_TYPE_DIR, buf + bufofs, sizeof(Efs_PageDirHeader_t))){
                bufofs += sizeof(Efs_PageDirHeader_t);
                if(isHdrType(EFS_TYPE_DIRSUM, buf + bufofs, sizeof(Efs_PageDirSumHeader_t))){
                    bufofs += sizeof(Efs_PageDirSumHeader_t);
                    if(!isHdrType(EFS_TYPE_DIRDEL, buf + bufofs, sizeof(Efs_PageDirDelHeade_t))){
                        //no delete
                        *address = ebofs;
                        memcpy(d_dh, buf + sizeof(Efs_PageEraseHeader_t), sizeof(Efs_PageDirHeader_t));
                        memcpy(d_ds, buf + sizeof(Efs_PageEraseHeader_t) + sizeof(Efs_PageDirHeader_t), sizeof(Efs_PageDirSumHeader_t));
                        return 0;
                    }
                }
            }
        }
        ebofs += EARSEBLOCK_SIZE;

    }
}

int popFile(uint32_t *address, Efs_PageDirHeader_t *d_dh, Efs_PageDirSumHeader_t *d_ds)
{
    uint32_t ebofs = ebhdr;
    uint8_t *buf = (uint8_t*)readBuf;
    uint32_t bufofs;
    ebofs = LROUND(ebhdr, EARSEBLOCK_SIZE);
    while(1){
        bufofs = 0;    
        read(ebofs, buf, sizeof(Efs_PageEraseHeader_t) + sizeof(Efs_PageDirHeader_t) + sizeof(Efs_PageDirSumHeader_t) + sizeof(Efs_PageDirDelHeade_t));
        if(isHdrType(EFS_TYPE_ERASE, buf, sizeof(Efs_PageEraseHeader_t))){
            bufofs += sizeof(Efs_PageEraseHeader_t);
            if(isHdrType(EFS_TYPE_DIR, buf + bufofs, sizeof(Efs_PageDirHeader_t))){
                bufofs += sizeof(Efs_PageDirHeader_t);
                if(isHdrType(EFS_TYPE_DIRSUM, buf + bufofs, sizeof(Efs_PageDirSumHeader_t))){
                    bufofs += sizeof(Efs_PageDirSumHeader_t);
                    if(!isHdrType(EFS_TYPE_DIRDEL, buf + bufofs, sizeof(Efs_PageDirDelHeade_t))){
                        //no delete
                        *address = ebofs;
                        memcpy(d_dh, buf + sizeof(Efs_PageEraseHeader_t), sizeof(Efs_PageDirHeader_t));
                        memcpy(d_ds, buf + sizeof(Efs_PageEraseHeader_t) + sizeof(Efs_PageDirHeader_t), sizeof(Efs_PageDirSumHeader_t));
                        return 0;
                    }
                }
            }
        }
            if(ebofs <= ebtail)
                return -1;
            if(ebofs >= EARSEBLOCK_SIZE){
                ebofs -= EARSEBLOCK_SIZE;
            }
            else
                return -1;
        
    }
    
}

int fileStreamOut(File_Opt opt, uint8_t* buf, uint32_t size)
{
    static Efs_PageDirHeader_t dh;
    static Efs_PageDirSumHeader_t ds;
    static Efs_PageNodeHeader_t n;
    static Efs_PageDirDelHeade_t dl;
    
    dl.magic = EFS_PAGE_MAGIC;
    dl.type = EFS_TYPE_DIRDEL;
    
    static uint32_t fileEbofs = 0;
    static uint32_t ebofs = 0;
    static uint32_t ofs = 0;
    static uint8_t pop = 0;
    
    uint32_t seek_ofs;
    uint32_t seek_ebofs;
    uint8_t* data;
    uint32_t ctlen;
    uint32_t left;
    uint32_t e_offset;
    
    switch(opt){
        case File_POPTAIL:
            if(0 > popTailFile(&fileEbofs, &dh, &ds))
                return 0;
            ebofs = fileEbofs + PAGE_SIZE;
            ofs = 0;
            pop = 1;
            if(size >= 8){
                memcpy(buf, &dh.id, 4);
                memcpy(buf+4, &dh.time, 4);
            }
            LOG(LOG_INFO, "poptail file: id = %x, time = %d at fileEbofs 0x%08x, ebsize 0x%08x\n", dh.id, dh.time, fileEbofs, ds.ebsize);
            return 1;

        case File_POP:
            if(0 > popFile(&fileEbofs, &dh, &ds))
                return 0;
            ebofs = fileEbofs + PAGE_SIZE;
            ofs = 0;
            pop = 0;
            if(size == 8 && buf){
                memcpy(buf, &dh.id, 4);
                memcpy(buf+4, &dh.time, 4);
            }
            LOG(LOG_INFO, "pop file: id = %x, time = %d at fileEbofs 0x%08x, ebsize 0x%08x\n", dh.id, dh.time, fileEbofs, ds.ebsize);
            return 1;

        case File_READ:
            //to end
            if(ebofs - fileEbofs >= ds.ebsize)
                    return 0;
            
            data = buf;
            left = size;
            while(left){
                e_offset = (ebofs&0xf00)? 0: sizeof(Efs_PageEraseHeader_t);
                read(ebofs + e_offset, (uint8_t*)&n, sizeof(Efs_PageNodeHeader_t));
                if(isHdrType(EFS_TYPE_NODE, (uint8_t*)&n, sizeof(Efs_PageNodeHeader_t))){
                    //LOG(LOG_INFO, "pop file ofs %d, n.offset %d, n.dsize %d\n", ofs, n.offset, n.dsize);
                    if(ofs >= n.offset && ofs < (n.offset + n.dsize)){
                        uint32_t nodeDataLeft = n.dsize - (ofs - n.offset);
                        ctlen = left > nodeDataLeft? nodeDataLeft: left;
                        read(ebofs + e_offset +sizeof(Efs_PageNodeHeader_t) + (ofs - n.offset), data, ctlen);
                        //syn
                        ofs += ctlen;
                        data += ctlen;
                        left -= ctlen;
                        //LOG(LOG_INFO, "pop file read ebofs 0x%08x, ctlen %d, left %d\n", ebofs, ctlen, left);
                        if(ctlen == nodeDataLeft)
                            ebofs += ROUND(n.dsize + sizeof(Efs_PageNodeHeader_t) + e_offset, PAGE_SIZE);
                    }
                    else{
                        ebofs += ROUND(n.dsize + sizeof(Efs_PageNodeHeader_t) + e_offset, PAGE_SIZE);
                    }
                }
                else{
                    //LOG(LOG_INFO, "hdrCheck: failed at ebofs 0x%08x\n", ebofs);
                    ebofs += PAGE_SIZE;
                }
                if(ebofs - fileEbofs >= ds.ebsize)
                    break;
                
            }
            LOG(LOG_INFO, "pop file read: end ebofs 0x%08x, ofs %d size %d\n", ebofs, ofs, size - left);
            return size - left;            

        case File_SEEK:
            
            memcpy(&seek_ofs, &buf, 4);
            if(seek_ofs > ds.tldsize)
                seek_ofs = ds.tldsize;
            if(seek_ofs < ofs){
                seek_ebofs = fileEbofs + PAGE_SIZE;
                left = seek_ofs;
            }
            else{
                left = seek_ofs - ofs;
                seek_ebofs = ebofs;
            }
            
            while(left){
                e_offset = (seek_ebofs&0xf00)? 0: sizeof(Efs_PageEraseHeader_t);
                read(seek_ebofs + e_offset, (uint8_t*)&n, sizeof(Efs_PageNodeHeader_t));
                if(isHdrType(EFS_TYPE_NODE, (uint8_t*)&n, sizeof(Efs_PageNodeHeader_t))){
                    LOG(LOG_INFO, "seek file ofs %d, n.offset %d, n.dsize %d\n", ofs, n.offset, n.dsize);
                    if(ofs >= n.offset && ofs < (n.offset + n.dsize)){
                        ofs = seek_ofs;
                        ebofs = seek_ebofs;
                        return ofs;
                    }
                    else{
                        seek_ebofs += ROUND(n.dsize + e_offset + sizeof(Efs_PageNodeHeader_t), PAGE_SIZE);
                    }
                }
                else{
                    //LOG(LOG_INFO, "hdrCheck: failed at ebofs 0x%08x\n", ebofs);
                    seek_ebofs += PAGE_SIZE;
                }
                if(seek_ebofs - fileEbofs >= ds.ebsize)
                    break;
            }
            
            break;
            
        case File_DEL:
            //ebtail -> next start position
            if(pop)
                addEbTail(ds.ebsize);
            dl.id = ds.id;
            dl.hcrc = crc32(0, (uint8_t*)&dl, offsetof(Efs_PageDirDelHeade_t, hcrc));
            writeDirDel(&dl, fileEbofs + sizeof(Efs_PageEraseHeader_t) + sizeof(Efs_PageDirHeader_t) + sizeof(Efs_PageDirSumHeader_t));
            writeflush();
            //syn
            LOG(LOG_INFO, "pop file del: id %x, at fileEbofs 0x%08x\n", dh.id, fileEbofs);
            break;

        default:
            break;
    }
    return 0;

}





iot_yet
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
应用系统数据缓存设计
ulalau的专栏
06-12 858
应用系统数据缓存设计 | 淘宝技术部 http://rdc.taobao.org/?p=1481
清除缓存功能
郎lang郎的博客
02-17 400
代码有点多，可以写一个工具类继承自NSObject 工具类.h文件#import <Foundation/Foundation.h> #import "UIImageView+WebCache.h" @interface ClearCacheTool : NSObject+(float)fileSizeAtPath:(NSString *)path; +(float)folderSizeAtPat
stm32之hal库串口中断和ringbuffer的结合
scl8295的博客
05-03 838
源文件 硬件初始化 测试 结果(测试ok，方便移植)
【ESP8266】app_IR_TxRx_demo中的RingBuf代码透析
代码就是生产力！
08-13 2473
在裸机单片机开发中，有时候需要用到先入先出队列（FIFO），可是一般的裸机开发环境是没有一个库函数给开发者使用队列的，这个时候需要自己写队列函数。后来，我在开发ESP8266和基于cc2530的contiki系统时，都发现这些系统下面有一个RingBuf文件，说明这个RingBuf就是为了解决裸机单片机开发中队列的问题。下面我来分析一下ESP8266中的RingBuf代码。
【FLASH存储器系列十九】固态硬盘掉电后如何恢复掉电前状态？
highman110的博客
02-10 1452
简述固态硬盘掉电恢复原理
jvm缓存行对齐
小仕一桩专栏
04-08 293
文章目录1、cpu缓存结构2、伪共享问题3、缓存行对齐4、Disruptor框架 1、cpu缓存结构   cpu内核的缓存一般分为一级缓存和二级缓存，三级缓存。cpu运行时，先从一级缓存读取数据，如果读取失败，则从二级缓存读取，读取失败，再从三级缓存和内存中读取数据。如下图   cpu读取缓存时数据时，以缓存行形式读取数据，从内存进入到三级缓存，二级缓存和一级缓存，最终有寄存器再进行处理。缓存行大小基于cpu架构，目前常见的为intel的x64架构，缓存行大小为64字节。 2、伪共享问题   由于缓存行这种
Rt-thead studio软件下使用ringbuffer
04-21
- 在RTOS中，RingBuffer常用于任务间通信、设备驱动层的数据缓存等场景，因为它的读写操作快速且同步简单。 2. **RT-Thread中的RingBuffer实现** - RT-Thread提供了标准的RingBuffer接口，包括`rt_ringbuf_create...
RingBuffer.zip
最新发布
05-10
环形缓冲区（RingBuffer）是一种在计算机编程中常见的数据结构，尤其在处理实时系统、多线程通信和数据流管理等场景下被广泛应用。它是一个固定大小的缓冲区，其设计灵感来源于数学上的圆环，因此得名。在环形缓冲区...
RingBuffer 循环缓存 亲测可用 V2 修改一处
12-17
4.当写入数据的长度大于ringbuffer的可写入长度时，多余的数据将会丢弃。所以写入数据前，先判断ringbuffer的可写入长度。另外程序包含示例。 支持windows平台的vs与linux平台的clion，语言级别实现，与平台无关。 ...
disruptorqueue:基于干扰器 RingBuffer 的阻塞队列实现
06-14
《基于Disruptor的RingBuffer实现的阻塞队列》 在Java并发编程领域，高效的数据传输和同步机制是至关重要的。Disruptor是一个由LMAX公司开发的高性能并发库，它提供了一种创新的解决方案——基于RingBuffer的阻塞...
适用于单片机的ringbuffer
12-29
适用于单片机的ringbuffer
NAND Flash上均匀损耗与掉电恢复在线测试
02-03
NAND Flash上均匀损耗与掉电恢复在线测试、电子技术,开发板制作交流
STM32 内部flash 数据掉电存储
qq_42074368的博客
10-22 4963
说明 对STM32内部的flash进行结构体数据存储，和读取。方便小型工程的数据掉电保存。 在初次使用的时候进行自动初始化默认值，后续掉电就不会再初始化了。 直接上代码 代码中的DATA_STORE需要自行定义结构体变量。 #include "store.h" #define FLASH_START 0x0803D800//flash起始地址 extern STORE_SHEET DATA_STORE;//数据存储结构体 extern u16 crc_cal_by_byte(const u8* ptr, u
乐鑫代码中Ring Buffers (环形缓冲区)说明
zhou_2018的博客
08-26 5299
本文翻译自乐鑫文档，详见链接地址，结合用例自行测试，欢迎交流。 Ring Buffers(环形缓冲区) ESP-IDF FreeRTOS环形缓冲区是严格的FIFO缓冲区，支持任意大小的项目。在项目大小可变的情况下，环形缓冲区是FreeRTOS队列的一种内存效率更高的替代方法。环形缓冲区的容量不是由它可以存储的项目数来衡量的，而是由用于存储项目的内存量来衡量的。您可以在环形缓冲区上申请一块内存来发送项目，或者只是使用API​​复制数据并发送（根据您调用的send API）。出于效率原因，总是通过引.
STM32----FLASH掉电保存动态平衡方案
a3748622的博客
04-11 8808
      stm32是支持对自身Flash（code区）进行读写的。所以，在某些需要掉电保存的场合，我们可以利用这一特性节省一个外部的Flash或者EEPROM，对数据进行保存。     但是，如果需要经常性的保存数据，就会对固定地址的Flash进行频繁的擦写，大大损耗Flash的寿命。在这种时候，就需要用到动态平衡的方法进行处理了。原理：一、Flash擦写寿命       根据网上查阅的资料，...
嵌入式硬件通信接口-使用RingBuffer处理数据（二）
DigCore的博客
11-19 1200
文章首发于同名微信公众号：DigCore 欢迎关注同名微信公众号：DigCore，及时获取最新技术博文。   经过上一篇《嵌入式硬件通信接口-使用RingBuffer处理数据(一)》简单了解循环缓冲区，读代码后，接着开始设计自己的循环缓冲区功能模块。 设计思路 这里设计的难点在于，如何把控tail这个写地址，每增加一个数据时tail自增，在写的过程中，如果使用缓冲区的所有空间，那么hea...
【STM32】FLASH擦写+FLASH相关操作+注意事项
永远年轻 永远热泪盈眶
08-21 5657
有关FLASH读写的函数： 有关库函数： 实现掉电不丢失的主函数（Flash一定要先擦后写）： #define FLASH_START_ADDR 0x0801f000 //写入的起始地址 int main (void){//主程序 u16 a; //定义变量 //初始化程序 RCC_Configuration(); //时钟设置 LED_Init();//L...
单片机FLASH和RAM内存分布
BachelorTse的博客
03-03 3723
STM32内置有Flash和RAM（而RAM分为SRAM和DRAM，STM32内为SRAM），硬件上他们是不同的设备存储器、属于两个器件，但这两个存储器的寄存器输入输出端口被组织在同一个虚拟线性地址空间内。 MDK预处理、编译、汇编、链接后编译窗口会显示如下一段关于程序和数据大小的信息： Code：是程序中代码所占字节大小； RO-data（Read Only-Data）：程序只读的变量，也就是带const的，和已初始化的字符串等； RW-data（Read Write-Data）：已初始化的可读写全局/
使用 Ring Buffer 完成数据传递
wangyx1234的博客
11-03 2296
1）Ring Buffer 提供了管理数据溢出的机制，当 Ring Buffer 的缓存区足够大时，数据写到缓冲区尾部后将自动从头部开始继续写。当 Ring Buffer 的缓冲区不够大时，即便存在数据溢出风险，但应用本身允许新数据覆盖旧数据的情况下使用 Ring Buffer 也非常合适。2）ESP-IDF 对 rIngbuf 的三种分类：No-Split buffers、Allow split buffers、Byte buffer。
在camera中，一个ringbuffer对应几个缓存区
05-22
在camera中，一个ringbuffer通常对应多个缓存区。具体来说，每个缓存区都是一段内存，用于存储从摄像头采集到的图像数据。在ringbuffer中，这些缓存区按照一定的顺序排列，形成一个环形缓存区。当摄像头采集到新的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值