### Initialize AT45DB Driver

Source: https://context7.com/omnisense/at45db/llms.txt

Instantiates the driver with specific SPI pins and performs automatic device setup, including binary page mode configuration and ID verification.

```cpp
#include "AT45DB.h"

// Initialize AT45DB with SPI pins (MOSI, MISO, SCLK, CS)
AT45DB flash(p5, p6, p7, p8);  // mbed LPC1768 example pins

// The constructor automatically:
// 1. Sets CS high (inactive)
// 2. Configures SPI frequency (up to 16MHz, limited by MAX_SPI_CLK)
// 3. Reads and verifies device ID (expects 0x1F2600 for AT45DB161E)
// 4. Configures binary page size (512 bytes) if not already set
```

--------------------------------

### Constructor - AT45DB

Source: https://context7.com/omnisense/at45db/llms.txt

Initializes the AT45DB flash memory driver. It configures SPI pins, performs device identification, and sets the chip to binary page mode (512 bytes per page).

```APIDOC
## Constructor - AT45DB

### Description
Creates and initializes an AT45DB flash memory driver instance by configuring SPI communication pins and performing device identification and setup. The constructor automatically sets the chip to binary page mode (512 bytes per page) and verifies the device ID.

### Method
Constructor

### Endpoint
N/A (Library Initialization)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
#include "AT45DB.h"

// Initialize AT45DB with SPI pins (MOSI, MISO, SCLK, CS)
AT45DB flash(p5, p6, p7, p8);  // mbed LPC1768 example pins
```

### Response
#### Success Response (Initialization)
Initializes the driver and configures the flash chip.

#### Response Example
N/A (Initialization is performed upon object creation)
```

--------------------------------

### at45_is_ready

Source: https://context7.com/omnisense/at45db/llms.txt

Checks if the flash device is ready to accept new commands by verifying if any internal operations are in progress.

```APIDOC
## at45_is_ready

### Description
Checks if the flash device is ready to accept new commands. Returns true when no internal operation (erase, program) is in progress.

### Response
- **bool** - Returns true if the device is ready, false otherwise.
```

--------------------------------

### Poll for device readiness

Source: https://context7.com/omnisense/at45db/llms.txt

Checks if the device is ready to accept new commands. Use this to poll for completion after write or erase operations.

```cpp
AT45DB flash(p5, p6, p7, p8);

// Example: Write multiple pages with ready polling
uint8_t data[AT45_PAGE_SIZE];
memset(data, 0x42, AT45_PAGE_SIZE);

for (int page = 0; page < 10; page++) {
    uint32_t addr = page * AT45_PAGE_SIZE;

    flash.at45_writepage(addr, data, AT45_PAGE_SIZE);

    // Poll until ready
    int timeout = 1000;
    while (!flash.at45_is_ready() && timeout > 0) {
        wait_ms(1);
        timeout--;
    }

    if (timeout == 0) {
        printf("Timeout waiting for page %d\n", page);
        break;
    }

    printf("Page %d written\n", page);
}
```

--------------------------------

### Verify AT45DB Device ID

Source: https://context7.com/omnisense/at45db/llms.txt

Reads the manufacturer and device identification codes to ensure the correct hardware is connected.

```cpp
AT45DB flash(p5, p6, p7, p8);

unsigned int chip_id = flash.at45_get_id();

// Expected: 0x1F2600 for AT45DB161E
printf("Chip ID: 0x%06X\n", chip_id);

if (chip_id == AT45DB161E_ID) {
    printf("AT45DB161E detected successfully\n");
} else {
    printf("Warning: Unexpected device ID\n");
}

// Full manufacturer and device verification
// Returns 0x1F260001 for genuine Adesto AT45DB161E
if (AT45_MANU_AND_DEVICE_ID(chip_id)) {
    printf("Verified Adesto manufacturer and device\n");
}
```

--------------------------------

### Read Data from Flash Page

Source: https://context7.com/omnisense/at45db/llms.txt

Reads data directly from main memory pages. Note that reading wraps to the beginning of the same page when the end is reached.

```cpp
AT45DB flash(p5, p6, p7, p8);

// Read a full page (512 bytes) from page 0
uint8_t read_buffer[AT45_PAGE_SIZE];
uint32_t page_address = 0;  // Page 0

if (flash.at45_readpage(page_address, read_buffer, AT45_PAGE_SIZE)) {
    printf("Read page 0 successfully\n");
    for (int i = 0; i < 16; i++) {
        printf("%02X ", read_buffer[i]);
    }
    printf("...\n");
}

// Read from page 100 (address = page_number * AT45_PAGE_SIZE)
uint32_t page_100_addr = 100 * AT45_PAGE_SIZE;  // 51200
uint8_t partial_buffer[64];

flash.at45_readpage(page_100_addr, partial_buffer, 64);
printf("First 64 bytes from page 100 read\n");
```

--------------------------------

### Enter Ultra-Deep Power-Down Mode

Source: https://context7.com/omnisense/at45db/llms.txt

Reduces power consumption to under 1µA by entering ultra-deep power-down mode. Note that all commands are ignored until the device exits this state.

```cpp
AT45DB flash(p5, p6, p7, p8);

// Complete any pending operations first
while (!flash.at45_is_ready()) {
    wait_ms(1);
}

printf("Entering ultra-deep power-down mode\n");
flash.at45_ultra_deep_pwrdown_enter();

// Device now consumes < 1uA
// All commands will be ignored until exit
printf("Flash in ultra-low power state\n");

// System can now enter sleep mode
// deepsleep();  // mbed deep sleep
```

--------------------------------

### Read AT45DB Status Register

Source: https://context7.com/omnisense/at45db/llms.txt

Retrieves the 16-bit status register to monitor device readiness, verify configuration, and check for operation errors.

```cpp
AT45DB flash(p5, p6, p7, p8);

uint16_t status = flash.at45_get_status();

// Check if device is ready for commands
if (AT45_STATUS_READY(status)) {
    printf("Device is ready\n");
}

// Verify binary page mode is configured
if (AT45_STATUS_BINARY(status)) {
    printf("Binary page mode (512 bytes/page)\n");
}

// Check for erase/program errors
if (AT45_STATUS_EP_ERROR(status)) {
    printf("Error: Erase/Program operation failed\n");
}

// Get device ID from status
uint8_t device_id = AT45_STATUS_ID(status);
printf("Device ID code: 0x%02X\n", device_id);
```

--------------------------------

### Write Data to Flash Page

Source: https://context7.com/omnisense/at45db/llms.txt

Writes a full page of data to main memory using an erase-before-program mechanism. Ensure the address is page-aligned and the buffer contains a full page of 512 bytes.

```cpp
AT45DB flash(p5, p6, p7, p8);

// Prepare a full page of data
uint8_t write_buffer[AT45_PAGE_SIZE];
for (int i = 0; i < AT45_PAGE_SIZE; i++) {
    write_buffer[i] = i & 0xFF;  // Test pattern
}

// Write to page 10 (address must be page-aligned)
uint32_t page_10_addr = 10 * AT45_PAGE_SIZE;  // 5120

if (flash.at45_writepage(page_10_addr, write_buffer, AT45_PAGE_SIZE)) {
    printf("Page write initiated\n");

    // Wait for write to complete
    while (!flash.at45_is_ready()) {
        // Busy wait or sleep
    }

    // Verify no errors occurred
    if (!flash.at45_is_ep_failed()) {
        printf("Page 10 written successfully\n");
    } else {
        printf("Error: Write operation failed\n");
    }
}
```

--------------------------------

### at45_readpage

Source: https://context7.com/omnisense/at45db/llms.txt

Reads data directly from a specified page in the main flash memory, bypassing internal RAM buffers. Supports reading full pages or partial page data.

```APIDOC
## at45_readpage

### Description
Reads data directly from a page in main memory, bypassing the internal RAM buffers. When the end of a page is reached, reading wraps to the beginning of the same page rather than continuing to the next page. Ideal for reading complete pages or partial page data.

### Method
GET

### Endpoint
N/A (Library Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

// Read a full page (512 bytes) from page 0
uint8_t read_buffer[AT45_PAGE_SIZE];
uint32_t page_address = 0;  // Page 0

if (flash.at45_readpage(page_address, read_buffer, AT45_PAGE_SIZE)) {
    printf("Read page 0 successfully\n");
    for (int i = 0; i < 16; i++) {
        printf("%02X ", read_buffer[i]);
    }
    printf("...\n");
}

// Read from page 100 (address = page_number * AT45_PAGE_SIZE)
uint32_t page_100_addr = 100 * AT45_PAGE_SIZE;  // 51200
uint8_t partial_buffer[64];

flash.at45_readpage(page_100_addr, partial_buffer, 64);
printf("First 64 bytes from page 100 read\n");
```

### Response
#### Success Response (200)
- **read_buffer** (uint8_t[]) - A buffer containing the data read from the specified page.
- **partial_buffer** (uint8_t[]) - A buffer containing the data read from a partial page read.

#### Response Example
```json
{
  "read_buffer": "[0xAA, 0xBB, 0xCC, ...]",
  "partial_buffer": "[0x11, 0x22, 0x33, ...]"
}
```
```

--------------------------------

### Wake the flash chip from ultra-deep power-down mode

Source: https://context7.com/omnisense/at45db/llms.txt

Wakes the device and verifies responsiveness. Note that internal RAM buffers contain undefined data after exiting this mode.

```cpp
AT45DB flash(p5, p6, p7, p8);

// Wake from ultra-deep power-down
printf("Exiting ultra-deep power-down mode\n");
flash.at45_ultra_deep_pwrdown_exit();

// Device is now ready for commands
// Note: Internal RAM buffers are now undefined

// Wait for device ready (should be immediate after exit)
while (!flash.at45_is_ready()) {
    wait_ms(1);
}

printf("Flash ready for operations\n");

// Verify device is responsive
unsigned int id = flash.at45_get_id();
if (id == AT45DB161E_ID) {
    printf("Device responding correctly after wake\n");
}
```

--------------------------------

### Commit Buffer to Flash Memory

Source: https://context7.com/omnisense/at45db/llms.txt

Programs the contents of the internal RAM buffer to a specified flash page. Use this after loading data into the buffer via at45_writebuffer().

```cpp
AT45DB flash(p5, p6, p7, p8);

// Build data in buffer
uint8_t config_data[256] = {0};
config_data[0] = 0x01;  // Config version
config_data[1] = 0x55;  // Config flags
// ... fill remaining config data

// Load into RAM buffer
flash.at45_writebuffer(0, config_data, 256);

// Program buffer to page 50
uint32_t page_50_addr = 50 * AT45_PAGE_SIZE;

if (flash.at45_buffer2memory(page_50_addr)) {
    printf("Buffer-to-memory transfer initiated\n");

    // Wait for completion
    while (!flash.at45_is_ready()) {
        wait_ms(1);
    }

    printf("Page 50 programmed from buffer\n");
}
```

--------------------------------

### at45_ultra_deep_pwrdown_enter

Source: https://context7.com/omnisense/at45db/llms.txt

Enters ultra-deep power-down mode, significantly reducing power consumption. In this mode, the device ignores all commands until reset or power cycle.

```APIDOC
## at45_ultra_deep_pwrdown_enter

### Description
Places the flash chip into ultra-deep power-down mode, reducing current consumption to less than 1µA. In this mode, all commands are ignored including status register reads. Ideal for battery-powered applications during extended sleep periods.

### Method
```cpp
flash.at45_ultra_deep_pwrdown_enter()
```

### Parameters
This method does not take any parameters.

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

// Complete any pending operations first
while (!flash.at45_is_ready()) {
    wait_ms(1);
}

printf("Entering ultra-deep power-down mode\n");
flash.at45_ultra_deep_pwrdown_enter();

// Device now consumes < 1uA
// All commands will be ignored until exit
printf("Flash in ultra-low power state\n");

// System can now enter sleep mode
// deepsleep();  // mbed deep sleep
```

### Response
This function does not return a value. Upon execution, the device enters ultra-deep power-down mode.
```

--------------------------------

### at45_buffer2memory

Source: https://context7.com/omnisense/at45db/llms.txt

Commits the contents of the internal RAM buffer to a flash memory page, performing an erase and program operation.

```APIDOC
## at45_buffer2memory

### Description
Commits the contents of the pre-loaded RAM buffer to a flash page. This function programs the entire buffer to the specified page with built-in erase. Use after at45_writebuffer() to finalize partial page updates.

### Method
```cpp
flash.at45_buffer2memory(uint32_t page_address)
```

### Parameters
#### Path Parameters
- **page_address** (uint32_t) - Required - The starting address of the page in flash memory to program the buffer contents to. Must be page-aligned.

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

// Build data in buffer
uint8_t config_data[256] = {0};
config_data[0] = 0x01;  // Config version
config_data[1] = 0x55;  // Config flags
// ... fill remaining config data

// Load into RAM buffer
flash.at45_writebuffer(0, config_data, 256);

// Program buffer to page 50
uint32_t page_50_addr = 50 * AT45_PAGE_SIZE;

if (flash.at45_buffer2memory(page_50_addr)) {
    printf("Buffer-to-memory transfer initiated\n");

    // Wait for completion
    while (!flash.at45_is_ready()) {
        wait_ms(1);
    }

    printf("Page 50 programmed from buffer\n");
}
```

### Response
#### Success Response (Boolean)
- **true**: If the buffer-to-memory transfer operation was successfully initiated.
- **false**: If the operation could not be initiated.

#### Error Handling
- **at45_is_ready()**: Poll this function to determine when the programming operation is complete.
- **at45_is_ep_failed()**: Check this function after completion to verify if an erase-program error occurred.
```

--------------------------------

### at45_get_status

Source: https://context7.com/omnisense/at45db/llms.txt

Reads the 16-bit status register from the AT45DB chip. This function provides information about the device's readiness, configuration, and error states.

```APIDOC
## at45_get_status

### Description
Reads the 16-bit status register from the AT45DB chip. The upper byte contains status byte 1 (ready/busy, device ID, page size config) and the lower byte contains status byte 2 (erase/program error flag). Use the provided macros to interpret the status value.

### Method
GET

### Endpoint
N/A (Library Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

uint16_t status = flash.at45_get_status();

// Check if device is ready for commands
if (AT45_STATUS_READY(status)) {
    printf("Device is ready\n");
}

// Verify binary page mode is configured
if (AT45_STATUS_BINARY(status)) {
    printf("Binary page mode (512 bytes/page)\n");
}

// Check for erase/program errors
if (AT45_STATUS_EP_ERROR(status)) {
    printf("Error: Erase/Program operation failed\n");
}

// Get device ID from status
uint8_t device_id = AT45_STATUS_ID(status);
printf("Device ID code: 0x%02X\n", device_id);
```

### Response
#### Success Response (200)
- **status** (uint16_t) - The 16-bit status register value.

#### Response Example
```json
{
  "status": 12345 
}
```
```

--------------------------------

### at45_ultra_deep_pwrdown_exit

Source: https://context7.com/omnisense/at45db/llms.txt

Wakes the flash chip from ultra-deep power-down mode by toggling the CS pin and applying necessary timing delays.

```APIDOC
## at45_ultra_deep_pwrdown_exit

### Description
Wakes the flash chip from ultra-deep power-down mode by asserting and deasserting the CS pin. After exit, the RAM buffers contain undefined data and must be reloaded if needed.

### Request Example
flash.at45_ultra_deep_pwrdown_exit();
```

--------------------------------

### at45_get_id

Source: https://context7.com/omnisense/at45db/llms.txt

Reads the manufacturer and device identification from the chip. Returns a 32-bit value for verification.

```APIDOC
## at45_get_id

### Description
Reads the manufacturer and device identification from the chip. Returns a 32-bit value containing the manufacturer ID, device family, and device series. Use this to verify the correct flash chip is connected.

### Method
GET

### Endpoint
N/A (Library Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

unsigned int chip_id = flash.at45_get_id();

// Expected: 0x1F2600 for AT45DB161E
printf("Chip ID: 0x%06X\n", chip_id);

if (chip_id == AT45DB161E_ID) {
    printf("AT45DB161E detected successfully\n");
} else {
    printf("Warning: Unexpected device ID\n");
}

// Full manufacturer and device verification
// Returns 0x1F260001 for genuine Adesto AT45DB161E
if (AT45_MANU_AND_DEVICE_ID(chip_id)) {
    printf("Verified Adesto manufacturer and device\n");
}
```

### Response
#### Success Response (200)
- **chip_id** (unsigned int) - A 32-bit value representing the manufacturer and device ID.

#### Response Example
```json
{
  "chip_id": 3288336 
}
```
```

--------------------------------

### at45_writepage

Source: https://context7.com/omnisense/at45db/llms.txt

Writes data to a specified page in flash memory. This operation includes an automatic erase of the target page before programming.

```APIDOC
## at45_writepage

### Description
Writes data to a page in main memory using the built-in erase-before-program mechanism. Data is first transferred to an internal RAM buffer, the target page is erased, and then the buffer contents are programmed into the page. The address must be page-aligned and the buffer should contain a full page (512 bytes) to avoid programming undefined data.

### Method
```cpp
flash.at45_writepage(uint32_t page_address, uint8_t* data, uint32_t size)
```

### Parameters
#### Path Parameters
- **page_address** (uint32_t) - Required - The starting address of the page to write to. Must be page-aligned.
- **data** (uint8_t*) - Required - A pointer to the buffer containing the data to be written.
- **size** (uint32_t) - Required - The number of bytes to write. Should be equal to the page size (512 bytes) for optimal results.

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

// Prepare a full page of data
uint8_t write_buffer[AT45_PAGE_SIZE];
for (int i = 0; i < AT45_PAGE_SIZE; i++) {
    write_buffer[i] = i & 0xFF;  // Test pattern
}

// Write to page 10 (address must be page-aligned)
uint32_t page_10_addr = 10 * AT45_PAGE_SIZE;  // 5120

if (flash.at45_writepage(page_10_addr, write_buffer, AT45_PAGE_SIZE)) {
    printf("Page write initiated\n");

    // Wait for write to complete
    while (!flash.at45_is_ready()) {
        // Busy wait or sleep
    }

    // Verify no errors occurred
    if (!flash.at45_is_ep_failed()) {
        printf("Page 10 written successfully\n");
    } else {
        printf("Error: Write operation failed\n");
    }
}
```

### Response
#### Success Response (Boolean)
- **true**: If the write operation was successfully initiated.
- **false**: If the operation could not be initiated (e.g., device not ready).

#### Error Handling
- **at45_is_ep_failed()**: Call this function after the write operation completes to check if an erase-program error occurred.
```

--------------------------------

### at45_writebuffer

Source: https://context7.com/omnisense/at45db/llms.txt

Writes data into the internal RAM buffer without programming to flash. This is useful for constructing data incrementally before committing to flash memory.

```APIDOC
## at45_writebuffer

### Description
Writes data into the currently selected internal RAM buffer without programming to flash. This allows building up partial page data before committing to main memory. The buffer alternates automatically between Buffer 1 and Buffer 2 for dual-buffer operations.

### Method
```cpp
flash.at45_writebuffer(uint32_t buffer_offset, uint8_t* data, uint32_t size)
```

### Parameters
#### Path Parameters
- **buffer_offset** (uint32_t) - Required - The offset within the internal RAM buffer where writing should begin.
- **data** (uint8_t*) - Required - A pointer to the buffer containing the data to write.
- **size** (uint32_t) - Required - The number of bytes to write to the internal buffer.

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

// Write partial data to RAM buffer
uint8_t header_data[32] = "HEADER DATA FOR FLASH PAGE....";
uint8_t payload_data[128];
memset(payload_data, 0xAA, sizeof(payload_data));

// Write header at buffer offset 0
flash.at45_writebuffer(0, header_data, 32);

// Write payload at buffer offset 32
flash.at45_writebuffer(32, payload_data, 128);

// Buffer now contains header + payload (160 bytes)
// Remaining buffer space contains previous/undefined data
printf("Buffer loaded with %d bytes of data\n", 32 + 128);
```

### Response
This function does not return a value but modifies the internal RAM buffer.
```

--------------------------------

### Write Data to RAM Buffer

Source: https://context7.com/omnisense/at45db/llms.txt

Writes partial data to the internal RAM buffer without triggering a flash program operation. Useful for building up page data before committing to main memory.

```cpp
AT45DB flash(p5, p6, p7, p8);

// Write partial data to RAM buffer
uint8_t header_data[32] = "HEADER DATA FOR FLASH PAGE....";
uint8_t payload_data[128];
memset(payload_data, 0xAA, sizeof(payload_data));

// Write header at buffer offset 0
flash.at45_writebuffer(0, header_data, 32);

// Write payload at buffer offset 32
flash.at45_writebuffer(32, payload_data, 128);

// Buffer now contains header + payload (160 bytes)
// Remaining buffer space contains previous/undefined data
printf("Buffer loaded with %d bytes of data\n", 32 + 128);
```

--------------------------------

### at45_is_ep_failed

Source: https://context7.com/omnisense/at45db/llms.txt

Checks the status register for erase/program failure flags to ensure data integrity after write operations.

```APIDOC
## at45_is_ep_failed

### Description
Checks the erase/program error flag in the status register. Returns true if the last erase or program operation failed.

### Response
- **bool** - Returns true if the last operation failed, false if successful.
```

--------------------------------

### Check for erase or program failure

Source: https://context7.com/omnisense/at45db/llms.txt

Checks the status register for errors after an operation. Always verify this to ensure data integrity.

```cpp
AT45DB flash(p5, p6, p7, p8);

uint8_t critical_data[AT45_PAGE_SIZE];
// ... fill with important data

uint32_t target_page = 100 * AT45_PAGE_SIZE;

// Write critical data
flash.at45_writepage(target_page, critical_data, AT45_PAGE_SIZE);

// Wait for completion
while (!flash.at45_is_ready()) {
    wait_ms(1);
}

// Verify operation succeeded
if (flash.at45_is_ep_failed()) {
    printf("CRITICAL: Flash write failed!\n");
    printf("Possible causes: wear-out, voltage issues, bad sector\n");
    // Implement error recovery or alert user
} else {
    printf("Flash write verified successful\n");
}
```

--------------------------------

### at45_erasepage

Source: https://context7.com/omnisense/at45db/llms.txt

Erases a specified page in flash memory, setting all bits to logic 1. This is typically used before writing new data if not using combined write functions.

```APIDOC
## at45_erasepage

### Description
Erases a single page in flash memory, setting all bits to logic 1. The page address should be aligned to page boundaries (lower 9 bits = 0 in binary page mode). Erase before programming if not using the combined write functions.

### Method
```cpp
flash.at45_erasepage(uint32_t page_address)
```

### Parameters
#### Path Parameters
- **page_address** (uint32_t) - Required - The starting address of the page to erase. Must be page-aligned.

### Request Example
```cpp
AT45DB flash(p5, p6, p7, p8);

// Erase page 25
uint32_t page_25_addr = 25 * AT45_PAGE_SIZE;

if (flash.at45_erasepage(page_25_addr)) {
    printf("Page erase initiated\n");

    // Wait for erase to complete
    while (!flash.at45_is_ready()) {
        wait_ms(1);
    }

    // Verify erase succeeded
    if (!flash.at45_is_ep_failed()) {
        printf("Page 25 erased successfully\n");

        // Verify page is erased (all 0xFF)
        uint8_t verify_buf[AT45_PAGE_SIZE];
        flash.at45_readpage(page_25_addr, verify_buf, AT45_PAGE_SIZE);

        bool erased = true;
        for (int i = 0; i < AT45_PAGE_SIZE; i++) {
            if (verify_buf[i] != 0xFF) {
                erased = false;
                break;
            }
        }
        printf("Erase verification: %s\n", erased ? "PASS" : "FAIL");
    }
}
```

### Response
#### Success Response (Boolean)
- **true**: If the erase operation was successfully initiated.
- **false**: If the operation could not be initiated.

#### Error Handling
- **at45_is_ready()**: Poll this function to determine when the erase operation is complete.
- **at45_is_ep_failed()**: Check this function after completion to verify if an erase-program error occurred.
```

--------------------------------

### Erase Flash Page

Source: https://context7.com/omnisense/at45db/llms.txt

Erases a single flash page, setting all bits to logic 1. Verify the operation using at45_is_ep_failed() and by reading back the page content.

```cpp
AT45DB flash(p5, p6, p7, p8);

// Erase page 25
uint32_t page_25_addr = 25 * AT45_PAGE_SIZE;

if (flash.at45_erasepage(page_25_addr)) {
    printf("Page erase initiated\n");

    // Wait for erase to complete
    while (!flash.at45_is_ready()) {
        wait_ms(1);
    }

    // Verify erase succeeded
    if (!flash.at45_is_ep_failed()) {
        printf("Page 25 erased successfully\n");

        // Verify page is erased (all 0xFF)
        uint8_t verify_buf[AT45_PAGE_SIZE];
        flash.at45_readpage(page_25_addr, verify_buf, AT45_PAGE_SIZE);

        bool erased = true;
        for (int i = 0; i < AT45_PAGE_SIZE; i++) {
            if (verify_buf[i] != 0xFF) {
                erased = false;
                break;
            }
        }
        printf("Erase verification: %s\n", erased ? "PASS" : "FAIL");
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.