ArduPilot存储管理 Storage EEPROM Flash

我不是女神ヾ 2022-06-07 04:39 172阅读 0赞

**AP\_HAL::Storage**  
此类可以应用于所有平台。PX4v1平台支持8k的EEPROM，Pixhawk平台支持16k的FRAM铁电存储器

存储大小定义：`libraries/AP_HAL/AP_HAL_Boards.h`中HAL\_STORAGE\_SIZE

**The DataFlash library**  
DataFlash是用来存储日志的。日志有固定的格式，固定的日志头和日志包头

//`日志头格式`
    // structure used to define logging format
    struct LogStructure {
        uint8_t msg_type;
        uint8_t msg_len;
        const char name[5];
        const char format[16];
        const char labels[64];
    };
    
    //`日志包头`
    #define LOG_PACKET_HEADER uint8_t head1, head2, msgid;

**日志举例**  
`libraries/DataFlash/examples/DataFlash_test/DataFlash_test.cpp`

struct PACKED log_Test {
        LOG_PACKET_HEADER;
        uint16_t v1, v2, v3, v4;
        int32_t  l1, l2;
    };

日志是以文件的形式存储到microSD card，可以直接拔出SD卡拷贝到PC

每个页首都有“日志文件的编号”和“日志文件的页号”。当用户下载日志时，非常有用

bool DataFlash_Block::WritePrioritisedBlock(const void *pBuffer, uint16_t size,
        bool is_critical)
    {
        // is_critical is ignored - we're a ring buffer and never run out
        // of space. possibly if we do more complicated bandwidth
        // limiting we can reservice bandwidth based on is_critical
    
        if (!CardInserted() || !log_write_started || !_writes_enabled) {
    
            return false;
        }
    
        if (! WriteBlockCheckStartupMessages()) {
    
            return false;
        }
    
        while (size > 0) {
       //while 判断条件 
            uint16_t n = df_PageSize - df_BufferIdx;
            if (n > size) {
                n = size;
            }
    
            if (df_BufferIdx == 0) {
                // if we are at the start of a page we need to insert a
                // page header
                if (n > df_PageSize - sizeof(struct PageHeader)) {
                    n = df_PageSize - sizeof(struct PageHeader);
                }
    
                struct PageHeader ph = { df_FileNumber, df_FilePage };// df_FileNumber, df_FilePage 初始化中从SD卡中读回 add 0xff
    
                BlockWrite(df_BufferNum, df_BufferIdx, &ph, sizeof(ph), pBuffer, n);//df_BufferNum 缓存区编号 0/1
                df_BufferIdx += n + sizeof(ph);
            } else {
    
                BlockWrite(df_BufferNum, df_BufferIdx, NULL, 0, pBuffer, n);
                df_BufferIdx += n;
            }
    
            size -= n;
            pBuffer = (const void *)(n + (uintptr_t)pBuffer);
    
            if (df_BufferIdx == df_PageSize) {
    
                FinishWrite();
                df_FilePage++;
            }
        }
    
        return true;
    }

**日志按块读写**  
用户需要设置page大小512 byte，当写满一页以后告诉芯片复制一页

日志本身是通过DataFlash\_File.cpp写到SD卡，还提供了DataFlash\_Empty.cpp的块设备读写接口，下面是应用铁电的读写实例

//缓冲区buffer
    static uint8_t buffer[2][DF_PAGE_SIZE]; 
    
    void DataFlash_Flash::Init(const struct LogStructure *structure, uint8_t num_types)
    {
        DataFlash_Backend::Init(structure, num_types);
        if (flash_fd == 0) {
            flash_fd = open(MTD_LOG_FILE, O_RDWR, 0777);
            if (flash_fd == -1) {
                printf("DataFlash_Flash init failed\n");
            }
        }
    
        df_PageSize = DF_PAGE_SIZE; //页大小
        df_NumPages = DF_NUM_PAGES - 1; //页数量
    }
    
    //读取flash数据到buffer
    void DataFlash_Flash::PageToBuffer(unsigned char BufferNum, uint16_t PageAdr)
    {
        PageAdr -= 1;
    
        uint16_t ofs = PageAdr * DF_PAGE_SIZE;
    
        memset(buffer[BufferNum], 0, DF_PAGE_SIZE);
    
        if (lseek(flash_fd, ofs, SEEK_SET) != ofs) {
            printf("PageToBuffer lseek err.\n");
            return;
        }
        if (read(flash_fd, buffer[BufferNum], DF_PAGE_SIZE) != DF_PAGE_SIZE)
        {
            printf("PageToBuffer read err.\n");
            return;
        }
    }
    
    //记录需要写入flash的页地址和缓冲区编号
    void DataFlash_Flash::BufferToPage (unsigned char BufferNum, uint16_t PageAdr, unsigned char wait)
    {   
        PageAdr -= 1;
        uint16_t ofs = PageAdr * DF_PAGE_SIZE;
    
        if(flash_fd < 0) return;
    
        if (lseek(flash_fd, ofs, SEEK_SET) != ofs) {
            printf("BufferToPage lseek err.\n");
            return;
        }
    
        if (::write(flash_fd, &buffer[BufferNum], DF_PAGE_SIZE) != DF_PAGE_SIZE)
        {
            printf("BufferToPage write err.\n");
            return;
        }
    }
    
    //数据写入缓冲区
    void DataFlash_Flash::BlockWrite(uint8_t BufferNum, uint16_t IntPageAdr,
                                    const void *pHeader, uint8_t hdr_size,
                                    const void *pBuffer, uint16_t size)
    {
       if (!_writes_enabled) {
            return;
        }
    
        memset(&buffer[BufferNum][IntPageAdr], 0, size+hdr_size);
    
        if (hdr_size) {
            memcpy(&buffer[BufferNum][IntPageAdr],
                   pHeader,
                   hdr_size);
        }
    
        memcpy(&buffer[BufferNum][IntPageAdr+hdr_size],
               pBuffer,
               size);
    }
    
    //从缓冲区读取数据
    bool DataFlash_Flash::BlockRead(uint8_t BufferNum, uint16_t IntPageAdr, void *pBuffer, uint16_t size)
    {
        memset(pBuffer, 0, size);
        memcpy(pBuffer, &buffer[BufferNum][IntPageAdr], size);
    
        return true;
    }