AT24C32.c

/*
 * AT24C32.c
 *
 * STM32 HAL driver for the AT24C32 I2C EEPROM. See AT24C32.h for the overview,
 * error handling, wiring and thread-safety notes.
 *
 *  Created on: Oct 7, 2026
 *      Author: johng
 */
 
#include "AT24C32.h"
#include <stdbool.h>
#include <string.h>
 
#define DEVICE_TYPE_BASE   0x50U
 
/* I2C error codes that a second attempt can fix (HAL_I2C_GetError()). */
#define I2C_TRANSIENT_ERRORS (HAL_I2C_ERROR_BERR | HAL_I2C_ERROR_ARLO | HAL_I2C_ERROR_AF | \
                              HAL_I2C_ERROR_OVR | HAL_I2C_ERROR_TIMEOUT)
 
static bool isTransient(I2C_HandleTypeDef *hi2c, HAL_StatusTypeDef status)
{
    if (status == HAL_BUSY || status == HAL_TIMEOUT) {
        return true;
    }
    if (status == HAL_ERROR) {
        return (HAL_I2C_GetError(hi2c) & I2C_TRANSIENT_ERRORS) != 0U;
    }
    return false;
}
 
static AT24C32_Status_t transfer(AT24C32_t *dev, bool write, uint16_t address, uint8_t *buffer, uint16_t length)
{
    uint8_t attempt;
 
    for (attempt = 1U; attempt <= dev->maxAttempts; attempt++) {
        HAL_StatusTypeDef status;
 
        if (write) {
            status = HAL_I2C_Mem_Write(dev->hi2c, dev->deviceAddress, address, I2C_MEMADD_SIZE_16BIT,
                                       buffer, length, AT24C32_I2C_TIMEOUT_MS);
        } else {
            status = HAL_I2C_Mem_Read(dev->hi2c, dev->deviceAddress, address, I2C_MEMADD_SIZE_16BIT,
                                      buffer, length, AT24C32_I2C_TIMEOUT_MS);
        }
 
        if (status == HAL_OK) {
            return AT24C32_OK;
        }
 
        dev->lastStatus = status;
 
        if (!isTransient(dev->hi2c, status)) {
            break;
        }
        HAL_Delay(1);
    }
 
    Error_Handler();
    return AT24C32_ERR_BUS;
}
 
static AT24C32_Status_t waitWriteComplete(AT24C32_t *dev)
{
    uint32_t start = HAL_GetTick();
    HAL_StatusTypeDef status;
 
    do {
        status = HAL_I2C_IsDeviceReady(dev->hi2c, dev->deviceAddress, 1U, AT24C32_I2C_TIMEOUT_MS);
        if (status == HAL_OK) {
            return AT24C32_OK;
        }
    } while ((HAL_GetTick() - start) <= AT24C32_WRITE_TIMEOUT_MS);
 
    dev->lastStatus = status;
    Error_Handler();
    return AT24C32_ERR_BUS;
}
 
AT24C32_Status_t at24c32Init(AT24C32_t *dev, I2C_HandleTypeDef *hi2c, uint8_t addressPins, uint8_t maxAttempts)
{
    HAL_StatusTypeDef status;
 
    if (dev == NULL || hi2c == NULL || addressPins > AT24C32_MAX_ADDRESS_PINS) {
        return AT24C32_ERR_PARAM;
    }
 
    dev->hi2c = hi2c;
    dev->deviceAddress = (uint16_t)((DEVICE_TYPE_BASE | addressPins) << 1);
    dev->maxAttempts = (maxAttempts == 0U) ? (uint8_t)AT24C32_DEFAULT_MAX_ATTEMPTS : maxAttempts;
    dev->lastStatus = HAL_OK;
 
    status = HAL_I2C_IsDeviceReady(hi2c, dev->deviceAddress, dev->maxAttempts, AT24C32_I2C_TIMEOUT_MS);
    if (status != HAL_OK) {
        dev->lastStatus = status;
        return AT24C32_ERR_NOT_FOUND;
    }
    return AT24C32_OK;
}
 
AT24C32_Status_t at24c32Read(AT24C32_t *dev, uint16_t memAddress, uint8_t *data, uint16_t length)
{
    if (dev == NULL || data == NULL || length == 0U ||
        memAddress >= AT24C32_SIZE_BYTES || length > (AT24C32_SIZE_BYTES - memAddress)) {
        return AT24C32_ERR_PARAM;
    }
 
    return transfer(dev, false, memAddress, data, length);
}
 
AT24C32_Status_t at24c32Write(AT24C32_t *dev, uint16_t memAddress, const uint8_t *data, uint16_t length)
{
    if (dev == NULL || data == NULL || length == 0U ||
        memAddress >= AT24C32_SIZE_BYTES || length > (AT24C32_SIZE_BYTES - memAddress)) {
        return AT24C32_ERR_PARAM;
    }
 
    while (length > 0U) {
        uint8_t page[AT24C32_PAGE_SIZE];
        uint16_t room = (uint16_t)(AT24C32_PAGE_SIZE - (memAddress % AT24C32_PAGE_SIZE));
        uint16_t chunk = (length < room) ? length : room;
 
        memcpy(page, data, chunk);   /* HAL takes a non-const pointer; a copy avoids casting const away */
 
        if (transfer(dev, true, memAddress, page, chunk) != AT24C32_OK ||
            waitWriteComplete(dev) != AT24C32_OK) {
            return AT24C32_ERR_BUS;
        }
 
        memAddress = (uint16_t)(memAddress + chunk);
        data += chunk;
        length = (uint16_t)(length - chunk);
    }
    return AT24C32_OK;
}