Flash Memory

// Flash endurance cycler - wears one sector out and logs how it dies.
// Board: ESP32 DevKit v1 + W25Q32 SPI NOR flash on a breakout.
//
// Endurance is quoted on every datasheet and almost never measured. It is measurable
// in a day, and the SHAPE of the failure is more informative than the number:
// failures cluster in the same few cells, and erase time rises before any bit fails.
// Those two facts together are the entire justification for wear levelling.
//
// WEARS OUT A REAL PART. Use a sacrificial device and cycle ONE sector so the rest of
// the chip stays healthy as a control.
//
// WIRING (VSPI): CS=5  SCK=18  MOSI=23  MISO=19   3.3 V ONLY - 5 V will destroy it.

#include <SPI.h>

#define CS_PIN        5
#define TEST_SECTOR   0x001000UL      // 4 kB sector under test
#define SECTOR_SIZE   4096
#define PAGE_SIZE     256
#define PATTERN       0xA5

#define CMD_WRITE_ENABLE 0x06
#define CMD_READ_STATUS  0x05
#define CMD_READ_DATA    0x03
#define CMD_PAGE_PROGRAM 0x02
#define CMD_SECTOR_ERASE 0x20
#define CMD_JEDEC_ID     0x9F

SPISettings spiCfg(8000000, MSBFIRST, SPI_MODE0);

void cmd(uint8_t c) {
  SPI.beginTransaction(spiCfg); digitalWrite(CS_PIN, LOW);
  SPI.transfer(c);
  digitalWrite(CS_PIN, HIGH); SPI.endTransaction();
}

void waitReady() {
  SPI.beginTransaction(spiCfg); digitalWrite(CS_PIN, LOW);
  SPI.transfer(CMD_READ_STATUS);
  while (SPI.transfer(0x00) & 0x01) { /* BUSY */ }
  digitalWrite(CS_PIN, HIGH); SPI.endTransaction();
}

void addr24(uint32_t a) {
  SPI.transfer((a >> 16) & 0xFF); SPI.transfer((a >> 8) & 0xFF); SPI.transfer(a & 0xFF);
}

unsigned long eraseSector(uint32_t a) {
  unsigned long t0 = micros();
  cmd(CMD_WRITE_ENABLE);
  SPI.beginTransaction(spiCfg); digitalWrite(CS_PIN, LOW);
  SPI.transfer(CMD_SECTOR_ERASE); addr24(a);
  digitalWrite(CS_PIN, HIGH); SPI.endTransaction();
  waitReady();
  return micros() - t0;
}

void programPage(uint32_t a, uint8_t value) {
  cmd(CMD_WRITE_ENABLE);
  SPI.beginTransaction(spiCfg); digitalWrite(CS_PIN, LOW);
  SPI.transfer(CMD_PAGE_PROGRAM); addr24(a);
  for (int i = 0; i < PAGE_SIZE; i++) SPI.transfer(value);
  digitalWrite(CS_PIN, HIGH); SPI.endTransaction();
  waitReady();
}

// Returns bytes that differ, and records WHERE - clustering is the point.
int verifySector(uint32_t a, uint8_t expect, uint32_t *firstBad) {
  int bad = 0; *firstBad = 0xFFFFFFFF;
  SPI.beginTransaction(spiCfg); digitalWrite(CS_PIN, LOW);
  SPI.transfer(CMD_READ_DATA); addr24(a);
  for (int i = 0; i < SECTOR_SIZE; i++) {
    if (SPI.transfer(0x00) != expect) { bad++; if (*firstBad == 0xFFFFFFFF) *firstBad = a + i; }
  }
  digitalWrite(CS_PIN, HIGH); SPI.endTransaction();
  return bad;
}

void setup() {
  Serial.begin(115200);
  pinMode(CS_PIN, OUTPUT); digitalWrite(CS_PIN, HIGH);
  SPI.begin();

  SPI.beginTransaction(spiCfg); digitalWrite(CS_PIN, LOW);
  SPI.transfer(CMD_JEDEC_ID);
  uint8_t m = SPI.transfer(0), t = SPI.transfer(0), c = SPI.transfer(0);
  digitalWrite(CS_PIN, HIGH); SPI.endTransaction();
  Serial.printf("# JEDEC id %02X %02X %02X\n", m, t, c);
  if (m == 0x00 || m == 0xFF) { Serial.println("# no device - check wiring and 3.3 V"); while (1) delay(1000); }

  Serial.println("cycle,erase_us,bad_bytes,first_bad_addr");

  for (unsigned long cycle = 1; ; cycle++) {
    unsigned long eus = eraseSector(TEST_SECTOR);

    uint32_t fb;
    int badErased = verifySector(TEST_SECTOR, 0xFF, &fb);   // erase should give all 0xFF

    for (int p = 0; p < SECTOR_SIZE / PAGE_SIZE; p++)
      programPage(TEST_SECTOR + p * PAGE_SIZE, PATTERN);

    int bad = verifySector(TEST_SECTOR, PATTERN, &fb);

    if (cycle % 100 == 0 || bad || badErased) {
      Serial.printf("%lu,%lu,%d,%08X\n", cycle, eus, bad + badErased,
                    fb == 0xFFFFFFFF ? 0 : fb);
    }
    // WATCH THE ERASE TIME COLUMN. It rises before any bit fails - trapped charge in
    // the tunnel oxide screens the field, so the internal state machine needs longer.
    // A real controller retires a block on exactly this signal.
  }
}

void loop() { }