Memorias externas y registro de datos

01 · El problema

Cuándo hace falta una memoria externa

Una memoria externa no es un lujo: agrega un chip, pines, consumo y complejidad, y por eso se la usa solo cuando la flash interna no alcanza o no es el lugar adecuado. Hay cuatro motivos habituales, cada uno con sus exigencias:

En todos los casos aparece una diferencia con la flash interna que cambia el diseño: la memoria externa vive al otro lado de un bus (I²C, SPI, SDIO), con su propio protocolo, su propio tiempo de escritura y sus propias fallas (un cable flojo, un chip que no responde, una tarjeta que se retira en caliente). Para el programa, no es memoria sino un periférico: se la accede mediante comandos, no con un puntero, y cada acceso puede fallar y tarda mucho más que uno a RAM. Eso se refleja en el diseño: la lectura y la escritura pasan por una capa de acceso con comprobación de errores y tiempos máximos (tema 39), y los datos se aplican con un buffer en RAM entre el programa y la memoria.

02 · El menú

Las opciones y cómo se comparan

Una distinción importa más que todas: memoria cruda frente a memoria gestionada. La EEPROM, la FRAM y la flash NOR son «crudas»: el programa maneja directamente los bytes, los borrados y el desgaste, y también las consecuencias de un corte. Una tarjeta SD o una eMMC son «gestionadas»: llevan un controlador interno que traduce los bloques lógicos de 512 B a la flash NAND real, reparte el desgaste, reemplaza los bloques defectuosos y corrige errores. Eso las hace más fáciles de usar y mucho menos predecibles: el controlador decide cuándo hace su limpieza interna, y esa limpieza es la causa de las pausas de cientos de milisegundos del apartado 7.

Y la interfaz fija la velocidad máxima. Con I²C a 400 kHz, un byte de datos ocupa 9 pulsos (8 de dato y uno de reconocimiento), de modo que el máximo teórico es de unos 44 KB/s, y en la práctica, con las direcciones y las pausas, unos 30 a 40 KB/s. Con SPI a 10 MHz hay 1,25 MB/s de ancho de banda en el bus; la memoria misma es el cuello de botella (la Parte 5 del programa de Python calcula que escribir 1 MB en una flash SPI lleva entre 15 y 23 segundos, es decir, entre 45 y 70 KB/s, porque dominan los tiempos de programación y de borrado, no la transferencia).

03 · La más usada

La flash SPI por dentro

La flash NOR con interfaz SPI es la memoria externa más difundida: barata, rápida de leer, con pocos pines y con un conjunto de comandos casi estándar entre fabricantes. Se maneja con comandos de un byte seguidos de una dirección y datos, y tiene las mismas reglas físicas que la flash interna (tema 28): borrada es 0xFF, programar solo baja bits y se borra por sector. Los comandos que hay que conocer:

Hay tres reglas que hacen fallar el primer driver de casi todos:

• Cada escritura o borrado necesita un WREN antes. Si se olvida, la operación se ignora en silencio: el programa cree haber escrito y la memoria no cambió. El WREN se «consume» con la operación.
• Tras iniciar una escritura o un borrado, hay que esperar a que termine consultando el bit WIP (con un tiempo máximo, tema 39). Durante ese tiempo, la memoria ignora los comandos de escritura. Los tiempos son del orden de 1 ms por página y de decenas de milisegundos por sector (en el peor caso, cientos).
• La programación de una página da la vuelta. Si una escritura de varios bytes cruza el final de una página de 256 B, los bytes que sobran no pasan a la página siguiente: vuelven a escribirse al principio de la misma página, pisando lo que había. Es el error más característico de estas memorias.

#define CMD_WREN  0x06
#define CMD_RDSR  0x05
#define CMD_READ  0x03
#define CMD_PP    0x02
#define CMD_SE    0x20
#define SR_WIP    0x01
#define PAGINA    256u

static void cmd_con_direccion(uint8_t cmd, uint32_t dir) {
    spi_enviar(cmd);  spi_enviar((uint8_t)(dir >> 16));  spi_enviar((uint8_t)(dir >> 8));  spi_enviar((uint8_t)dir);
}

static bool esperar_listo(uint32_t timeout_ms) {                    /* con tiempo máximo: una flash que no responde no bloquea el programa */
    uint32_t t0 = ahora_ms();
    for (;;) {
        cs_bajo();  spi_enviar(CMD_RDSR);  uint8_t sr = spi_recibir();  cs_alto();
        if (!(sr & SR_WIP)) return true;
        if ((int32_t)(ahora_ms() - t0) >= (int32_t)timeout_ms) return false;
    }
}

static void habilitar_escritura(void) { cs_bajo();  spi_enviar(CMD_WREN);  cs_alto(); }

bool flash_borrar_sector(uint32_t dir) {
    habilitar_escritura();
    cs_bajo();  cmd_con_direccion(CMD_SE, dir);  cs_alto();
    return esperar_listo(500);                                      /* típico 45 ms; peor caso, cientos de ms */
}

/* Programar un bloque de cualquier tamaño: se parte en pedazos que NO crucen el final de una página */
bool flash_programar(uint32_t dir, const uint8_t *datos, size_t n) {
    while (n > 0) {
        size_t cabe = PAGINA - (dir & (PAGINA - 1));                  /* lo que falta hasta el final de la página actual */
        size_t k = (n < cabe) ? n : cabe;
        habilitar_escritura();
        cs_bajo();  cmd_con_direccion(CMD_PP, dir);  spi_enviar_buf(datos, k);  cs_alto();
        if (!esperar_listo(5)) return false;                        /* típico 0,7 ms; máximo 3 ms */
        dir += (uint32_t)k;  datos += k;  n -= k;
    }
    return true;
}

La Parte 4 del programa de Python muestra qué pasa con el error de la página: al escribir 20 bytes a partir de la posición 250 de una página de 256 B, el driver ingenuo deja los primeros 6 bytes en su lugar (250 a 255) y los 14 restantes (los valores 7 a 20) al principio de la misma página, en las posiciones 0 a 13, pisando lo que hubiera; el correcto los ubica en la página siguiente. El resultado ingenuo parece correcto en una prueba con datos que no cruzan un límite y falla en producción con el primer registro que lo cruza, y ese registro, además, corrompe un dato anterior sin dejar ningún error. Por eso un buen diseño elige registros cuyo tamaño divide a la página (16 o 32 bytes en una de 256): ninguno cruza jamás un límite.

Antes de confiar en nada, el driver debe comprobar el chip: leer el JEDEC ID y compararlo con el esperado. Un ID de 0xFFFFFF o 0x000000 es el síntoma clásico de un bus mal conectado (chip sin alimentación, selección de chip mal cableada, líneas cruzadas) y evita horas de depuración de «escribe pero no lee».

04 · Gran capacidad, poca previsibilidad

Las tarjetas SD

Una tarjeta SD ofrece gigabytes por poco dinero y se puede sacar y llevar a una PC, lo que la hace la elección natural para registros masivos. Se accede en bloques de 512 bytes por dos interfaces: SPI (más simple, cuatro pines y cualquier microcontrolador la soporta, pero más lenta) y SDIO (con 1 o 4 líneas de datos y mucha más velocidad, que requiere un periférico específico). Sobre ella casi siempre se monta un sistema de archivos FAT, con la biblioteca FatFs (de ChaN) como opción más difundida.

Una SD tiene una forma de comportarse que el programador de firmware debe conocer, porque no se parece a la de una flash cruda:

Para un registro continuo en una SD con FatFs, hay un puñado de prácticas que marcan la diferencia entre un registrador que funciona años y uno que corrompe la tarjeta a las dos semanas:

• Preasignar el archivo (en FatFs, f_expand) a su tamaño final: las escrituras no tienen que ampliar el archivo ni actualizar la tabla de asignación con cada bloque.
• Escribir siempre en múltiplos de 512 B (el tamaño de bloque), alineados: un registro de 64 B se acumula en un buffer de RAM de 512 B (8 registros) y se escribe junto.
• No abrir y cerrar el archivo con cada registro: es lento y desgasta la tabla. Se abre una vez, se escribe de a bloques y se sincroniza (f_sync) cada tanto, por ejemplo cada 10 s o cada N bloques. El intervalo es un compromiso: más seguido, menos datos perdidos en un corte pero más escrituras y más consumo.
• Rotar los archivos (uno por día o por tamaño) en lugar de uno gigante: si se corrompe uno, se pierde un día y no todo.
• Escribir desde una tarea de baja prioridad con una cola que desacopla a quien produce los datos del que espera la tarjeta (tema 21).

05 · Archivos en un microcontrolador

Sistemas de archivos livianos

Un sistema de archivos organiza una memoria en archivos con nombres, y se justifica cuando hay varios archivos, de tamaño variable, que cambian. Para un único registro circular, o para una configuración de pocos parámetros, es un lujo innecesario: el diseño propio de los apartados 6 y del tema 40 es más simple, más pequeño y más fácil de verificar. Pero cuando la cantidad y el tamaño de los datos crecen, un sistema de archivos probado vale lo que cuesta. Los más usados en sistemas embebidos:

La diferencia que más pesa para un equipo en el campo es la tolerancia a cortes. FAT sobre una tarjeta SD no la ofrece por sí sola: un corte durante la actualización de la tabla puede dejar un sistema de archivos inconsistente. littlefs fue diseñado alrededor de ese problema: usa copia en escritura (nunca pisa un bloque con datos válidos, igual que la doble copia del tema 40) y garantiza que, tras un corte, el sistema de archivos queda en un estado consistente, el anterior o el posterior a la operación. Si el equipo se apaga de golpe con frecuencia, esa garantía vale más que la compatibilidad con la PC.

Un sistema de archivos también ocupa recursos: código (decenas de KB), RAM (buffers del tamaño de un bloque o de una página, a veces varios) y tiempo. Un microcontrolador con 2 KB de RAM no puede con FatFs; uno con 20 KB sí, a costa de una parte considerable. Por eso la pregunta no es «¿qué sistema de archivos?» sino primero «¿hace falta uno?»: muchas veces un registro circular de registros de tamaño fijo (apartado siguiente) resuelve el problema con 200 líneas de código y sin ocupar casi RAM.

06 · El diseño central

El registro circular de datos

El registro circular (circular log) es la estructura más importante de este tema: un anillo de sectores en el que se escriben registros de tamaño fijo, uno detrás de otro, hasta llenar un sector; entonces se pasa al siguiente (que se borra antes de usarse), y cuando se llega al último sector se vuelve al primero, sobrescribiendo lo más viejo. Es la misma idea del registro circular en flash que vimos en el tema 40 para guardar variables, ahora para guardar series de datos, y resuelve sin esfuerzo tres problemas a la vez:

• El desgaste se reparte solo: cada sector se borra una vez por vuelta completa al anillo, así que todos se desgastan por igual (nivelación dinámica gratis).
• Los cortes de energía son inofensivos: cada registro tiene un CRC; el que estaba a medio escribir queda con un CRC inválido y se ignora, y todos los anteriores siguen válidos.
• La memoria nunca se llena: cuando se agota el espacio, se sobrescribe lo más viejo, con una política explícita (apartado siguiente y tema 30).

Cada registro es una unidad autocontenida: un número de secuencia (que crece), el contenido (marca de tiempo y valores) y un CRC. Con 16 bytes, que divide a la página de 256 B (así ninguno cruza un límite) y al sector de 4 KB (256 registros por sector):

typedef struct {
    uint32_t seq;               /* número de secuencia: crece con cada registro */
    uint32_t t;                 /* marca de tiempo */
    int16_t  valor[2];          /* los datos medidos */
    uint8_t  estado;            /* banderas */
    uint8_t  _relleno;
    uint16_t crc;               /* CRC-16 de los 14 bytes anteriores */
} RegistroLog;                  /* 16 bytes: divide a la página (256) y al sector (4096) */

#define REG_TAM   16u
#define SECTOR    4096u
#define N_SECTORES 4096u        /* flash de 16 MB */
#define LOG_TAM   (SECTOR * N_SECTORES)

static uint32_t cabeza;         /* dirección donde se escribe el próximo registro: vive en RAM, se recupera al arrancar */
static uint32_t sig_seq;

void log_agregar(const Muestra *m) {
    RegistroLog r = { .seq = sig_seq, .t = m->t, .valor = { m->a, m->b }, .estado = m->estado };
    r.crc = crc16((const uint8_t *)&r, REG_TAM - 2);

    if (cabeza % SECTOR == 0) flash_borrar_sector(cabeza);          /* entrar a un sector nuevo: borrarlo ANTES de usarlo */
    flash_programar(cabeza, (const uint8_t *)&r, REG_TAM);
    cabeza = (cabeza + REG_TAM) % LOG_TAM;
    sig_seq++;
}

La posición de escritura vive en RAM y se pierde con la energía, de modo que el arranque tiene que recuperarla. No hace falta recorrer los 16 MB: basta mirar el primer registro de cada sector (4096 lecturas de 16 bytes), quedarse con el sector de mayor secuencia, que es el que se estaba llenando, y dentro de él buscar la primera posición libre:

/* Versión simplificada de la recuperación del arranque */
void log_recuperar(void) {
    bool hay = false;  uint32_t mejor_seq = 0, mejor_sector = 0;
    for (uint32_t s = 0; s < N_SECTORES; s++) {                      /* solo el primer registro de cada sector */
        RegistroLog r;  flash_leer(s * SECTOR, &r, sizeof r);
        if (registro_valido(&r) && (!hay || (int32_t)(r.seq - mejor_seq) > 0)) { mejor_seq = r.seq; mejor_sector = s; hay = true; }
    }
    if (!hay) { cabeza = 0; sig_seq = 0; return; }                  /* memoria en blanco: primer arranque */

    uint32_t pos = mejor_sector * SECTOR, fin = pos + SECTOR, ultima = mejor_seq;
    for (RegistroLog r; pos < fin; pos += REG_TAM) {                /* recorrer los registros válidos del sector actual */
        flash_leer(pos, &r, sizeof r);
        if (!registro_valido(&r)) break;
        ultima = r.seq;
    }
    while (pos < fin && registro_a_medias_en(pos)) pos += REG_TAM;    /* saltar lo que quedó a medias (CRC inválido, no está borrado) */
    cabeza = pos % LOG_TAM;                                         /* si el sector se llenó, la cabeza queda al inicio del siguiente */
    sig_seq = ultima + 1;
}

La Parte 3 del programa de Python lo prueba con 300 ensayos sobre una flash simulada pequeña (4 sectores, 16 registros): cada ensayo escribe entre 40 y 120 registros (dando varias vueltas al anillo) y corta la energía a mitad del último. En los 300 casos, el arranque recupera la posición correcta, todos los registros completos siguen ahí, sin saltos en la secuencia, y el registro a medias es detectado y descartado por el CRC (300 de 300). Después de recuperar, la escritura sigue sin problemas. El registro a medias no se reutiliza (la flash no permite reprogramarlo sin borrar): queda como un hueco de un registro hasta que su sector se borre en la próxima vuelta.

Qué hacer cuando el anillo se llena

Si los datos no se descargan a tiempo, el anillo da la vuelta y sobrescribe los más viejos. Es una decisión de producto, y no hay una respuesta única:

Y para saber qué se descargó, se guarda el número de secuencia del último registro confirmado por el servidor, en un lugar persistente aparte (tema 40). Los registros con una secuencia menor o igual ya pueden sobrescribirse sin pérdida. En el laboratorio de este tema se ve la diferencia entre un registro «subido» y uno «pendiente» y cómo los sobrescritos sin subir se cuentan como pérdida.

07 · El tiempo que la memoria no te deja

Las pausas de la memoria y el buffer en RAM

Hay un tipo de falla que no es de datos sino de tiempo: mientras la memoria está ocupada (borrando un sector, programando una página, haciendo su limpieza interna una tarjeta), el programa no puede escribir, y si las muestras siguen llegando, se pierden a menos que haya un buffer en RAM que las guarde. Un borrado de sector de una flash SPI tarda típicamente 45 ms pero puede tardar 400 ms en el peor caso; una escritura a una tarjeta SD puede tardar hasta 250 ms de golpe, aunque casi siempre sea mucho menos. El buffer necesario es la tasa de datos por la pausa máxima, y la Parte 2 del programa lo calcula:

Los números dan una lección de diseño: un registro de 1 kHz con un peor caso de 400 ms necesita 6,4 KB de RAM solo para las pausas, más que toda la RAM de un microcontrolador chico, y con 64 B por registro y una tarjeta SD, 16 KB. Hay cuatro maneras de bajar la necesidad, y se combinan:

• Borrar por adelantado (pre-erase): en vez de borrar el sector en el momento exacto en que se necesita, borrar el siguiente sector mientras se escribe en el actual, o durante un momento tranquilo. La escritura en el sector nuevo no tiene que esperar el borrado. En el código del apartado 6, la línea que borra al entrar a un sector se reemplaza por un borrado en segundo plano del sector que sigue. Elimina la pausa más larga.
• Escribir desde una tarea separada, con una cola o un buffer circular que desacople a quien produce de quien espera (tema 21), y dimensionar la cola con la fórmula de arriba.
• Reducir la tasa o el tamaño del registro: más compacto (menos bytes por muestra), o agregado (promedios), o disparado por eventos (tema 35).
• Usar DMA para la transferencia por SPI: libera a la CPU mientras se envían los 256 bytes de la página, aunque no acorta el tiempo de programación de la memoria, que es el cuello de botella.

Y siempre hay que decidir qué se hace si el buffer se llena de todos modos: perder las muestras nuevas, perder las más viejas del buffer o frenar el muestreo. En todos los casos, se cuenta y se registra (tema 39): un contador de muestras perdidas por buffer lleno es una señal de salud tan útil como el de errores de comunicación.

08 · El costo escondido

Energía y vida útil

Una memoria externa suma al presupuesto de energía (tema 33), y mucho más si es una tarjeta. Tres líneas del presupuesto:

• Reposo: una flash SPI en deep power-down consume del orden de 1 µA; sin ese comando, unas decenas de µA. Una tarjeta SD, en cambio, consume en reposo de cientos de µA a varios mA según el modelo (la tarjeta no puede apagarse por comando), por lo que en un equipo a batería se la alimenta a través de un interruptor y se la apaga entre grupos de escrituras (a costa de la inicialización de cada encendido, que lleva decenas a cientos de milisegundos).
• Escritura: programar y borrar una flash exige decenas de mA durante milisegundos (el borrado es lo más caro, como se vio en el capacitor de reserva del tema 40); una tarjeta SD, decenas de mA durante la escritura. La energía por registro baja cuando se agrupan los registros en bloques: un solo encendido y una sola escritura de un bloque completo cuestan mucho menos que muchas pequeñas.
• Picos: las corrientes de una tarjeta pueden hundir la tensión de una batería con resistencia interna alta (tema 36) y provocar un brown-out (tema 37) justo cuando más importa no perder datos. Se mitiga con un capacitor cerca de la tarjeta y con una alimentación robusta.

La vida útil de un registro circular en flash NOR rara vez es un problema, y la Parte 1 del programa lo muestra con una flash de 16 MB y registros de 16 B (1 048 576 registros, 4096 sectores): a un registro por segundo el anillo guarda 12,1 días y se desgasta recién a los 3325 años, y a un registro por milisegundo guarda 17,5 minutos y se desgasta en 3 años. El motivo es que el anillo reparte el desgaste entre 4096 sectores: aun a 1 kHz, cada sector se borra una vez cada 17,5 minutos, unas 30 000 veces por año de las 100 000 que aguanta. Es un buen recordatorio de que el desgaste importa mucho para una variable que se reescribe en el lugar (tema 40) y casi nada para un registro circular grande. Lo que sí hay que vigilar en una tarjeta SD es la calidad de la tarjeta y la escritura de la tabla de asignación, no la endurancia teórica de la flash.

09 · Comprobar que funciona

Verificación y diagnóstico

10 · Analogía con programación

Probar el modelo en Python

El programa tiene cinco partes: la capacidad y la vida útil de un registro circular en una flash SPI de 16 MB para distintas frecuencias de registro; el buffer de RAM necesario para sobrevivir a las pausas del borrado y de una tarjeta SD; la prueba con 300 cortes de energía de un registro circular sobre una flash simulada; la demostración del error de la frontera de página en el programador de una flash SPI; y el tiempo de escribir 1 MB con distintas velocidades del bus.

# Memorias externas y registro de datos: capacidad y vida útil, buffers para las esperas, un registro circular con cortes y el error de la página.
import random

def crc16(datos):
    crc = 0xFFFF
    for b in datos:
        crc ^= b << 8
        for _ in range(8): crc = ((crc << 1) ^ 0x1021) & 0xFFFF if crc & 0x8000 else (crc << 1) & 0xFFFF
    return crc

# ---- Parte 1: capacidad y vida útil de un registro en una flash SPI de 16 MB ----------------------------------------
FLASH, SECTOR, REG, ENDURANCIA = 16 * 1024 * 1024, 4096, 16, 100_000
regs_total = FLASH // REG
print("Parte 1: flash SPI de 16 MB, sectores de 4 KB, registros de 16 B, endurancia de 100 000 borrados por sector")
print(f"  capacidad: {regs_total:,} registros ({FLASH // SECTOR} sectores de {SECTOR // REG} registros)".replace(",", " "))
print(f"  {'un registro cada':>18} | {'el anillo guarda':>18} | {'se desgasta tras':>18}")
def duracion(s):
    if s < 3600: return f"{s / 60:,.1f} minutos".replace(",", " ")
    if s < 86400 * 2: return f"{s / 3600:,.1f} horas".replace(",", " ")
    if s < 365 * 86400 * 2: return f"{s / 86400:,.1f} días".replace(",", " ")
    return f"{s / (365 * 86400):,.0f} años".replace(",", " ")
for etiqueta, seg in (("1 ms", 0.001), ("1 s", 1), ("1 min", 60), ("1 h", 3600)):
    guarda_s = regs_total * seg
    vida_s = guarda_s * ENDURANCIA
    print(f"  {etiqueta:>18} | {duracion(guarda_s):>18} | {duracion(vida_s):>18}")

# ---- Parte 2: cuánta RAM hace falta para sobrevivir a las esperas de la memoria ---------------------------------------
print()
print("Parte 2: buffer en RAM para no perder datos mientras la memoria está ocupada")
casos = (("flash SPI: borrado de sector, típico 45 ms", 1000, 16, 0.045), ("flash SPI: borrado de sector, peor caso 400 ms", 1000, 16, 0.400),
         ("tarjeta SD: pausa de escritura de hasta 250 ms", 100, 64, 0.250), ("tarjeta SD: pausa de 250 ms a 1 kHz y 64 B", 1000, 64, 0.250))
for nombre, hz, bytes_reg, espera in casos:
    tasa = hz * bytes_reg
    print(f"  {nombre:<48}: {hz:>4} reg/s de {bytes_reg:>2} B = {tasa / 1000:5.1f} KB/s -> RAM mínima {tasa * espera / 1000:5.2f} KB ({int(hz * espera) + 1} registros)")

# ---- Parte 3: un registro circular en flash, con cortes de energía --------------------------------------------------------
SEC, REGS_POR_SEC, SECTORES = 64, 4, 4                    # una flash pequeña para simular: 4 sectores de 64 B, registros de 16 B
class Flash:
    def __init__(self):
        self.m = bytearray(b"\xff" * (SEC * SECTORES)); self.borrados = [0] * SECTORES
    def borrar(self, s):
        self.m[s * SEC:(s + 1) * SEC] = b"\xff" * SEC; self.borrados[s] += 1
    def programar(self, dir_, datos, corte=None):
        for i, b in enumerate(datos):
            if corte is not None and i >= corte: return False      # se cortó la energía: quedó a medias
            self.m[dir_ + i] &= b
        return True
def armar_registro(seq):
    cuerpo = seq.to_bytes(4, "big") + bytes([seq % 251] * 10)
    return cuerpo + crc16(cuerpo).to_bytes(2, "big")
def leer_registro(f, i):
    r = bytes(f.m[i * REG:(i + 1) * REG])
    if r == b"\xff" * REG: return "vacio", None
    ok = crc16(r[:-2]) == int.from_bytes(r[-2:], "big")
    return ("valido", int.from_bytes(r[:4], "big")) if ok else ("parcial", None)
TOTAL_SLOTS = SECTORES * REGS_POR_SEC
def arrancar(f):
    """Recupera la posición de escritura: después del registro válido de mayor secuencia, saltando lo que quedó a medias."""
    mejor, pos = -1, None
    for i in range(TOTAL_SLOTS):
        est, seq = leer_registro(f, i)
        if est == "valido" and seq > mejor: mejor, pos = seq, i
    if pos is None: return 0, 0
    h = (pos + 1) % TOTAL_SLOTS
    while leer_registro(f, h)[0] == "parcial": h = (h + 1) % TOTAL_SLOTS
    return h, mejor + 1
def escribir(f, h, seq, corte=None):
    if h % REGS_POR_SEC == 0 and any(leer_registro(f, h + k)[0] != "vacio" for k in range(REGS_POR_SEC)): f.borrar(h // REGS_POR_SEC)
    return f.programar(h * REG, armar_registro(seq), corte)

print()
print("Parte 3: registro circular de 16 registros (4 sectores); 300 ensayos, cada uno con 40 a 120 registros y un corte de energía en medio del último")
rnd = random.Random(12)
fallos, descartados = 0, 0
for ensayo in range(300):
    f = Flash(); h, seq = arrancar(f)
    n = rnd.randint(40, 120)
    for k in range(n):
        escribir(f, h, seq); h = (h + 1) % TOTAL_SLOTS; seq += 1
    escribir(f, h, seq, corte=rnd.randint(1, REG - 1))                    # el último guardado se corta
    h2, seq2 = arrancar(f)                                                # arranque: recuperar
    validos = sorted(s for i in range(TOTAL_SLOTS) for e, s in [leer_registro(f, i)] if e == "valido")
    parciales = sum(leer_registro(f, i)[0] == "parcial" for i in range(TOTAL_SLOTS))
    contiguos = all(b - a == 1 for a, b in zip(validos, validos[1:]))
    ultimo_ok = bool(validos) and validos[-1] == seq - 1                 # el último registro COMPLETO sobrevivió
    if not (contiguos and ultimo_ok and seq2 == seq): fallos += 1
    descartados += parciales
    for _ in range(5): escribir(f, h2, seq2); h2 = (h2 + 1) % TOTAL_SLOTS; seq2 += 1   # tras recuperar se sigue escribiendo
print(f"  ensayos con registros perdidos, saltos en la secuencia o posición mal recuperada: {fallos} de 300")
print(f"  registros a medias detectados y descartados por el CRC: {descartados} (uno por ensayo)")
print("  borrados por sector tras el último ensayo:", f.borrados)

# ---- Parte 4: el error de la frontera de página ---------------------------------------------------------------------------
PAG = 256
def programar_pagina_ingenuo(mem, dir_, datos):
    """Una flash SPI NOR: al pasar el final de la página, la escritura DA LA VUELTA al principio de la MISMA página."""
    base = dir_ - dir_ % PAG
    for i, b in enumerate(datos):
        pos = base + (dir_ % PAG + i) % PAG
        mem[pos] &= b
def programar_bien(mem, dir_, datos):
    i = 0
    while i < len(datos):
        n = min(PAG - (dir_ + i) % PAG, len(datos) - i)             # lo que cabe hasta el final de la página actual
        programar_pagina_ingenuo(mem, dir_ + i, datos[i:i + n]); i += n
mem1, mem2 = bytearray(b"\xff" * 1024), bytearray(b"\xff" * 1024)
datos = bytes(range(1, 21))                                          # 20 bytes escritos a partir del byte 250 de la página (cruzan el final)
programar_pagina_ingenuo(mem1, 250, datos); programar_bien(mem2, 250, datos)
print()
print("Parte 4: escribir 20 bytes a partir de la posición 250 de una página de 256 B")
print(f"  ingenuo: bytes 250..255 = {list(mem1[250:256])}, bytes 0..13 de la misma página = {list(mem1[0:14])}  (la escritura dio la vuelta y pisó el inicio de la página)")
print(f"  correcto: bytes 250..255 = {list(mem2[250:256])}, bytes 256..269 = {list(mem2[256:270])}")
print(f"  el ingenuo cumple lo pedido: {bytes(mem1[250:270]) == datos}; el correcto: {bytes(mem2[250:270]) == datos}")

# ---- Parte 5: tiempo de escribir 1 MB en una flash SPI ----------------------------------------------------------------------
print()
print("Parte 5: escribir 1 MB en una flash SPI (páginas de 256 B, programación de 0,7 ms, borrado de sector de 4 KB de 45 ms)")
paginas = (1024 * 1024) // 256
sectores = (1024 * 1024) // 4096
for mhz in (1, 10, 40):
    transferencia = (256 + 4) * 8 / (mhz * 1e6)                       # datos + 4 bytes de comando y dirección
    total = paginas * (0.7e-3 + transferencia) + sectores * 45e-3
    print(f"  SPI a {mhz:>2} MHz: transferencia por página {transferencia * 1000:5.2f} ms; total {total:5.2f} s ({1024 / total:6.0f} KB/s); el borrado aporta {sectores * 45e-3:.1f} s")

Resultado, parte 1: con una flash de 16 MB y registros de 16 B hay 1 048 576 registros en 4096 sectores de 256; el anillo guarda 17,5 minutos a un registro por milisegundo (y se desgasta en 3 años), 12,1 días a uno por segundo (3325 años), 728,2 días a uno por minuto (199 501 años) y 120 años a uno por hora. Parte 2: a 1000 registros por segundo de 16 B (16 KB/s), un borrado de 45 ms pide 0,72 KB de RAM y uno de 400 ms, 6,40 KB; con una tarjeta SD y pausas de 250 ms, 100 registros por segundo de 64 B piden 1,60 KB y 1000 por segundo, 16,00 KB. Parte 3: en 300 ensayos con 40 a 120 registros y un corte en el último, hubo 0 fallos de recuperación (sin pérdidas ni saltos de secuencia) y 300 registros a medio escribir detectados y descartados por el CRC. Parte 4: al escribir 20 bytes a partir de la posición 250, el driver ingenuo deja los bytes 7 a 20 en las posiciones 0 a 13 de la misma página y no cumple lo pedido; el correcto los coloca en la página siguiente y sí. Parte 5: escribir 1 MB lleva 22,91 s a 1 MHz (45 KB/s), 15,24 s a 10 MHz (67 KB/s) y 14,60 s a 40 MHz (70 KB/s), de los cuales 11,5 s son de borrado: subir 40 veces la velocidad del bus ahorra apenas un 36 % del tiempo.

Probá cambiar REG a 24 (un registro que ya no divide a la página) y mirá cómo la prueba de la Parte 3 sigue funcionando pero ahora puede haber registros que crucen un sector, o cambiá el tamaño del anillo (SECTORES) para ver cuántos borrados recibe cada sector. La lección de la Parte 5 es útil: la velocidad del bus importa mucho menos que el tiempo de programación y de borrado de la memoria; para ir más rápido hay que escribir menos, no usar un reloj más rápido.

11 · Exploración interactiva

El anillo de registros

El laboratorio es un registro circular de 6 sectores con 8 registros cada uno (48 ranuras). Escribís registros (cada uno con su número de secuencia), el anillo borra cada sector al entrar a él y, cuando da la vuelta, sobrescribe los más viejos. Podés subir los registros pendientes al servidor (se vuelven azules y pueden sobrescribirse sin pérdida), programar un corte de energía a mitad del próximo registro y hacer el arranque, que recupera la posición de escritura. Los registros sobrescritos sin haberse subido se cuentan como pérdida.

Recorrido guiado

1. Apretá «Escribir 10»: se llena el sector 0 (8 registros) y se empieza el 1. Mirá que cada registro tiene su número de secuencia y que el contorno naranja marca dónde se escribe el próximo. Los números entre paréntesis de cada sector cuentan los borrados.
2. Apretá «Escribir 50» dos veces: el anillo (48 ranuras) da una vuelta completa y empieza a sobrescribir. Cada vez que entra a un sector lleno, lo borra primero (el contador de borrados sube) y descarta sus registros. Los registros sobrescritos sin haber sido subidos aparecen en «Perdidos».
3. Apretá «Reiniciar», luego «Escribir 10» dos veces (20 registros) y «Subir lo pendiente»: los 20 registros se vuelven azules. Escribí 28 más (lo que falta para llenar el anillo de 48 ranuras) y después 16 más: el anillo entra de nuevo a los sectores 0 y 1, cuyos registros ya estaban subidos, y «Perdidos» sigue en 0. Si escribís 8 más, al entrar al sector 2 se borran 4 registros que no se habían subido (los números 21 a 24) y ahora «Perdidos» marca 4: solo se pierde lo que se sobrescribe sin subir. Es la razón de guardar el último número de secuencia confirmado.
4. Apretá «Cortar la energía en el próximo registro» y luego «Escribir 1»: el registro queda a medias (rojo rayado, CRC inválido) y el sistema se apaga: la posición de escritura, que estaba en RAM, se perdió. Los registros anteriores siguen intactos.
5. Apretá «Arranque y recuperación»: el sistema encuentra el registro válido de mayor secuencia, salta el parcial (no se puede reprogramar sin borrar su sector) y reanuda en la ranura siguiente. Escribí unos registros más: la secuencia continúa sin saltos ni repeticiones. El hueco del parcial desaparece cuando el anillo vuelve a borrar ese sector.
6. Programá un corte justo cuando la próxima escritura entra a un sector nuevo (fijate dónde está el contorno naranja: en la primera ranura de un sector): el sector se borra y el registro queda a medias en la primera ranura. El arranque recupera igual: el sector nuevo tiene un parcial y nada válido, y la posición se reanuda detrás del parcial.

12 · Método de trabajo

Método: un registro de datos que no falla

1. Calculá lo que necesitás antes de elegir el chip: bytes por registro, registros por segundo, cuánto tiempo hay que retener sin descargar, y el peor caso de pausa de la memoria. De ahí salen la capacidad y la RAM del buffer.
2. Elegí memoria cruda o gestionada según qué necesitás: flash NOR SPI para registros y recursos con control total; tarjeta SD para gran capacidad y extracción; FRAM para contadores frecuentes. Y preguntate si hace falta un sistema de archivos.
3. Escribí un driver con comprobaciones: verificar el JEDEC ID, WREN antes de cada operación, esperar el WIP con un tiempo máximo, partir las escrituras en la frontera de página, y toda operación con resultado comprobado (tema 39).
4. Diseñá el registro con tamaño fijo que divida a la página, con secuencia y CRC en cada uno, en un anillo de sectores; borrá cada sector antes de entrar a él, o mejor, por adelantado.
5. Escribí la recuperación del arranque antes que el resto: encontrar la cabeza y la secuencia, saltar el registro parcial, y tolerar memoria en blanco y CRC dañados.
6. Desacoplá con un buffer en RAM dimensionado para la pausa más larga, y escribí desde una tarea aparte; contá las muestras perdidas por buffer lleno.
7. Decidí la política de anillo lleno (sobrescribir lo viejo, parar, agregar, anillos separados) y guardá el último número de secuencia confirmado por el servidor.
8. Si usás una SD: preasignar archivos, escribir bloques de 512 B alineados, sincronizar periódicamente, rotar archivos, alimentarla por un interruptor, y probar con la tarjeta real.
9. Presupuestá la energía: reposo de la memoria (deep power-down o interruptor), picos de escritura y agrupación de registros.
10. Probá los cortes en cada paso con una flash simulada y con cortes reales aleatorios, y la falla o extracción de la memoria sin colgarse.

13 · Comprensión

Confusiones frecuentes

14 · Práctica guiada

Ejercicios

1. ¿Cuánto guarda?

Una flash SPI de 8 MB guarda registros de 32 bytes, uno cada 10 segundos, en un anillo. ¿Cuántos registros caben? ¿Cuánto tiempo de datos guarda?

2. El buffer para un borrado

Un equipo produce 500 registros por segundo de 24 bytes. El peor caso de borrado de sector es de 400 ms. ¿Cuántos registros y cuántos bytes de RAM hacen falta como mínimo para no perder datos durante el borrado? ¿Cómo se evitaría el problema?

3. La frontera de página

Se quiere programar 100 bytes a partir de la dirección 0x1F0 de una flash con páginas de 256 bytes. ¿En cuántas operaciones de Page Program se parte y de qué tamaño? ¿Qué pasaría si se enviara en una sola?

4. Tiempo de escribir un sector

Con una flash SPI a 10 MHz (0,21 ms de transferencia por página), programación de 0,7 ms por página y borrado de sector de 45 ms, ¿cuánto tarda en reescribirse un sector completo de 4 KB (borrar y programar 16 páginas)? ¿A cuántos KB/s equivale?

5. Una SD en un registrador

Un equipo registra 100 registros por segundo de 64 bytes en una SD de 8 GB (8 × 10⁹ bytes). ¿Cuántos bytes por día? ¿Cuántos días hasta llenarla? Si se acumulan 8 registros en un buffer de 512 B antes de escribir, ¿cada cuánto se escribe?

6. Una vuelta del anillo

Con la flash de 16 MB, registros de 16 B y un registro por segundo, el anillo da una vuelta cada 12,1 días. ¿Cuántas veces se borra cada sector por año? ¿Cuántos años tarda en agotar los 100 000 borrados?

15 · Síntesis

Ideas para recordar

¿Listo para el tema siguiente?

Antes de avanzar, calculá el registro de datos de un producto tuyo: bytes por registro, registros por segundo, días que debe retener, pausa máxima de la memoria. De ahí: capacidad, buffer en RAM y tamaño de registro. Después probá, aunque sea con una flash simulada en la PC, el corte de energía en cada paso de un guardado, incluido el de un registro que cruza una frontera de página.

En el próximo tema usamos estas memorias para algo crítico: la actualización de firmware. Cargadores de arranque, particiones A y B, actualización por cable y por aire (OTA), y cómo hacerlo sin que un corte de energía deje al equipo inutilizado.