Forma eficiente de escribir en la memoria flash sin perder datos

Question

Para mi proyecto, estoy escribiendo un código que obtiene algunos resultados y quiero almacenar estos resultados en una memoria flash externa. La memoria flash externa en cuestión es una MX25R8035F . Descubrí que escribir sin borrar sólo funciona la primera vez que escribo algo en una dirección.

Pero debido a esto me estoy encontrando con algunos problemas de memoria. El borrado más pequeño es un borrado de sector (4096 bytes.) Si quiero escribir en una dirección específica primero tendría que leer el sector que contiene esa dirección, cambiar los bytes que quiero que se cambien y luego escribir todo el sector (la escritura es sólo por página.)

¿Existe una forma más eficiente de utilizar esta memoria flash externa? Específicamente usando menos memoria para cambiar uno o dos bytes.

La función que utilizo ahora esto se puede encontrar a continuación:

uint8_t EXT_FLASH_write(size_t address, uint8_t *buf, size_t length) {

/*
 * The entire sector will be erased when writing to an offset inside that sector
 * Therefore this function will first retrieve all data inside the sector and update the retrieved
 * data with the values inside buff which and will then write the entire content back to the sector
 */

    uint8_t wbuf[4];
    SPI_Transaction transaction;
    uint32_t sectorBaseAddr;
    uint8_t temp[EXT_FLASH_ERASE_SECTOR_SIZE];
    uint8_t tries;
    size_t ilen; /* interim length per instruction */
    uint32_t bufIndex = 0;
    uint8_t pageIterations;

    while (length > 0) {
        // first retrieve entire sector so it can be erased on the chip
        sectorBaseAddr = EXT_FLASH_SECTOR_BASE_ADDR(address);
        EXT_FLASH_read(sectorBaseAddr, temp, EXT_FLASH_ERASE_SECTOR_SIZE);

        // Erase the sector on the chip
        EXT_FLASH_erase(address, EXT_FLASH_ERASE_SECTOR_SIZE);

        ilen = EXT_FLASH_PROGRAM_PAGE_SIZE
                - (address % EXT_FLASH_PROGRAM_PAGE_SIZE);
        if (length < ilen)
            ilen = length;

        memcpy(temp + (address - sectorBaseAddr), buf + bufIndex, length);

        bufIndex += ilen;
        address += ilen;
        length -= ilen;

        tries = 0;
        if (EXT_FLASH_writeEnable() != 0) {
            if (tries == EXT_FLASH_MAX_TRIES) {
                return 1;
            }
            tries++;
        }
        tries = 0;
        while (EXT_FLASH_waitReady() != 2) {
            if (tries == EXT_FLASH_MAX_TRIES) {
                return 1;
            }
            EXT_FLASH_writeEnable();
            tries++;
        }

        // programming the external flash can only be done in pages
        // so divide current sector into pages and write each page separately
         for (pageIterations = 0;
                 pageIterations * EXT_FLASH_PROGRAM_PAGE_SIZE
                         < EXT_FLASH_ERASE_SECTOR_SIZE; pageIterations++) {
            EXT_FLASH_select();

            wbuf[0] = EXT_FLASH_CODE_PROGRAM;
            wbuf[1] = ((sectorBaseAddr
                    + (pageIterations * EXT_FLASH_PROGRAM_PAGE_SIZE)) >> 16)
                    & 0xff;
            wbuf[2] = ((sectorBaseAddr
                    + (pageIterations * EXT_FLASH_PROGRAM_PAGE_SIZE)) >> 8)
                    & 0xff;
            wbuf[3] = (sectorBaseAddr
                    + (pageIterations * EXT_FLASH_PROGRAM_PAGE_SIZE)) & 0xff;

            // Configure the transaction
            transaction.count = sizeof(wbuf);
            transaction.txBuf = wbuf;
            transaction.rxBuf = NULL;

            if (!SPI_transfer(masterSpi, &transaction)) {
                /* failure */
                EXT_FLASH_deselect();
                return 1;
            }
            // Configure the transaction
            transaction.count = EXT_FLASH_PROGRAM_PAGE_SIZE;
            transaction.txBuf = temp
                    + (pageIterations * EXT_FLASH_PROGRAM_PAGE_SIZE);
            transaction.rxBuf = NULL;

            if (!SPI_transfer(masterSpi, &transaction)) {
                /* failure */
                EXT_FLASH_deselect();
                return 1;
            }

            EXT_FLASH_deselect();
        }
    }
    return 0;
}

Answer 1

La FLASH es barata y proporciona mucha memoria, pero tiene el coste del borrado de sectores. Por lo tanto, es posible que desee utilizar EEPROM en su lugar.

Por supuesto, es posible superar esta limitación del flash con algún software inteligente, que rastrea los bits y bytes con un revista (es decir, no se sobrescribe un valor de byte sino que se escribe una nueva copia del mismo y se anota en el diario que el nuevo byte es el reciente). Pero esto es una sobrecarga de software muy grande y es posible que no quieras hacerlo.

Answer 2

Hay una nota de aplicación muy buena de microchip. El algoritmo de esta nota de aplicación soporta EEPROMs de datos múltiples y seleccionables con un tamaño total de hasta múltiplos de 255 ubicaciones. La sobrecarga en este diario no es tan grande y es realmente fácil y cómodo de usar.