HAL_StatusTypeDef
Eeprom::writeEEPROM(uint16_t address, 
                    uint8_t* MemTarget,
                    uint16_t Size)
{
    uint16_t Counter = 0;
    HAL_StatusTypeDef Result = HAL_OK;
    while (Counter < Size && Result == HAL_OK) {
        uint16_t Portion = Size - Counter;          // Все, що залишилося -- у одну порцію
        if (Portion > EEPROM_MAXPKT) Portion = EEPROM_MAXPKT; // Порція завелика, зменшуємо
        // Працюємо із порцією, яку можна проковтнути
        Result = HAL_I2C_Mem_Write(i2c_port, EEPROM_ADDRESS,
                    address + Counter, I2C_MEMADD_SIZE_16BIT,
                    &MemTarget[Counter], Portion, EEPROM_TIMEOUT);
        // І реєструємо, що вже це зробили.
        Counter += Portion;

        HAL_Delay(EEPROM_WRITE);
    }
    return Result;
}

// Для 24C512 треба до EEPROM_ADDRESS при address >= 0x10000 додати 0x1 або 0x2
// залежно від того, зсунуту чи не зсунуту адресу I2C використовує HAL
// Тобто аргумент виклику
//   EEPROM_ADDRESS + ((address & 0x10000) >> 16),
// або 15, якщо адреса I2C вже зсунута вліво
HAL_StatusTypeDef
Eeprom::writeEEPROM(unsigned address,
                    const uint8_t * pdata,
                    unsigned len)
{
    HAL_StatusTypeDef result = HAL_OK;

    // Перша порція не може бути більша, щоб не перетнула розмір сторінки
    unsigned max_portion = size_to_page_end(address);
    unsigned portion;

    while (len != 0 && result == HAL_OK) {
        portion = len;                       // Все, що залишилося -- у одну порцію
        if (portion > max_portion) portion = max_portion;  // Порція завелика, зменшуємо
        // Працюємо із порцією, яку можна проковтнути
        result = HAL_I2C_Mem_Write(i2c_port,
                    EEPROM_ADDRESS, // для 24C512 див коментар
                    address, I2C_MEMADD_SIZE_16BIT,
                    pdata, portion, EEPROM_TIMEOUT);
        // І реєструємо, що вже це зробили.
        len     -= portion;
        address += portion;
        pdata   += portion;
        // наступне, якщо взагалі буде, буде від початку сторінки
        max_portion = page_size;

        HAL_Delay(EEPROM_WRITE);
    }

    return result;
}

/*
 * AT24Cxx.h
 *
 *  Created on: 20 трав. 2018 р.
 *      Author: Andriy
 */

#ifndef AT24CXX_H_
#define AT24CXX_H_

#include "stm32f1xx_hal.h"
#include "stdbool.h"

#define    EEPROM_I2C            hi2c1
#define EEPROM_ADDRESS        0x50
//#define EEPROM_MAXPKT        32                    //(page size)
#define EEPROM_PAGESIZE        128
#define EEPROM_WRITE        10                    //time to wait in ms
#define EEPROM_TIMEOUT        5 * EEPROM_WRITE    //timeout while writing

extern I2C_HandleTypeDef EEPROM_I2C;

HAL_StatusTypeDef AT24Cxx_IsConnected(void);
HAL_StatusTypeDef AT24Cxx_ReadEEPROM(unsigned address, const void* src, unsigned len);
HAL_StatusTypeDef AT24Cxx_WriteEEPROM(unsigned address, const void* src, unsigned len);

#endif /* AT24CXX_H_ */

/*
 * AT24Cxx.c
 *
 *  Created on: 20 трав. 2018 р.
 *      Author: Andriy
 */
#include "AT24Cxx.h"

// Перетворюємо адресу з 7 біт на на 8 біт
static unsigned eeprom_address = EEPROM_ADDRESS << 1;
// Маску обчислюємо по заданому розміру сторінки.
static unsigned inpage_addr_mask = EEPROM_PAGESIZE - 1;

static HAL_StatusTypeDef AT24Cxx_WriteReadEEPROM(unsigned address, const void* src, unsigned len, bool write);
static unsigned size_to_page_end(unsigned addr);

HAL_StatusTypeDef AT24Cxx_IsConnected(void)
{
    return HAL_I2C_IsDeviceReady(&EEPROM_I2C, eeprom_address, 1, EEPROM_TIMEOUT);
}

HAL_StatusTypeDef AT24Cxx_ReadEEPROM(unsigned address, const void* src, unsigned len)
{
    return AT24Cxx_WriteReadEEPROM(address, src, len, false);
}

HAL_StatusTypeDef AT24Cxx_WriteEEPROM(unsigned address, const void* src, unsigned len)
{
    return AT24Cxx_WriteReadEEPROM(address, src, len, true);
}

static HAL_StatusTypeDef AT24Cxx_WriteReadEEPROM(unsigned address, const void* src, unsigned len, bool write)
{
    uint8_t *pdata = (uint8_t*) src;

    HAL_StatusTypeDef result = HAL_OK;

    // Перша порція не може бути більша, щоб не перетнула розмір сторінки
    unsigned max_portion = size_to_page_end(address);
    unsigned portion;

    while (len != 0 && result == HAL_OK)
    {
        portion = len;              // Все, що залишилося -- у одну порцію

        if (portion > max_portion)
        {
            portion = max_portion;  // Порція завелика, зменшуємо
        }

        // Працюємо із порцією, яку можна проковтнути
        if(write)
        {
            result = HAL_I2C_Mem_Write(&EEPROM_I2C,
                                    eeprom_address,
                                    address,
                                    I2C_MEMADD_SIZE_16BIT,
                                    pdata,
                                    portion,
                                    EEPROM_TIMEOUT);
        }
        else
        {
            result = HAL_I2C_Mem_Read(&EEPROM_I2C,
                                    eeprom_address,
                                    address,
                                    I2C_MEMADD_SIZE_16BIT,
                                    pdata,
                                    portion,
                                    EEPROM_TIMEOUT);
        }

        // І реєструємо, що вже це зробили.
        len     -= portion;
        address += portion;
        pdata   += portion;

        // наступне, якщо взагалі буде, буде від початку сторінки
        max_portion = EEPROM_PAGESIZE;

        if(write)
        {
            HAL_Delay(EEPROM_WRITE);
        }
        else
        {
            HAL_Delay(EEPROM_WRITE / 2);
        }
    }

    return result;
}

// обчислення відстані до кінця сторінки
static unsigned size_to_page_end(unsigned addr)
{
    return (~addr & inpage_addr_mask) + 1;
}

/* USER CODE BEGIN 2 */

  UART_SendStr("UART is OK!\n\r");

  if(AT24Cxx_IsConnected() == HAL_OK)
  {
      UART_SendStr("EEPROM is OK!\n\r");

      char str1[] = "https://stm32withoutfear.blogspot.com/2018/05/stm32-eeprom-at24xxx-i2c.html";

      if(AT24Cxx_WriteEEPROM(196, str1, sizeof(str1) / sizeof(str1[0])) == HAL_OK)
      {
          UART_SendStr("EEPROM save is OK!\n\r");
      }
      else
      {
          UART_SendStr("EEPROM save is failed!\n\r");
      }

      unsigned var1 = 12345678;

      if(AT24Cxx_WriteEEPROM(60, &var1, sizeof(var1)) == HAL_OK)
      {
          UART_SendStr("EEPROM save is OK!\n\r");
      }
      else
      {
          UART_SendStr("EEPROM save is failed!\n\r");
      }

      char str2[128] = {};
      unsigned var2;
      AT24Cxx_ReadEEPROM(196, str2, 128);
      UART_SendStr(str2);
      UART_SendStr("\n\r");
      AT24Cxx_ReadEEPROM(60, &var2, sizeof(var2));
      UART_SendInt(var2);
      UART_SendStr("\n\r");
  }
  /* USER CODE END 2 */

typedef struct{
    int intVar;
    char str[256];
    uint8_t flag;
    uint16_t save;
}ExampleTypeDef;

/* USER CODE BEGIN 2 */

  UART_SendStr("UART is OK!\n\r");

  if(AT24Cxx_IsConnected() == HAL_OK)
  {
      UART_SendStr("EEPROM is OK!\n\r");
      UART_SendStr("Size data = ");
      UART_SendInt(sizeof(example));
      UART_SendStr("\n\r");
// Читання завершується != HAL_OK.
      if(AT24Cxx_ReadEEPROM(396, &example, sizeof(example)))
      {
          if(example.save != 0xABCD)
          {
              example.flag = 1;
                example.intVar = 12345678;
                example.save = 0xABCD;
                strcpy(example.str, "Testing for save any data structure. Thank you, ReAl!!! The link http://replace.org.ua/topic/9430/");

                if(AT24Cxx_WriteEEPROM(396, &example, sizeof(example)))
              {
                  UART_SendStr("EEPROM save is OK!\n\r");
              }
              else
              {
                  UART_SendStr("EEPROM save is failed!\n\r");
              }
          }

          UART_SendInt(example.intVar);
          UART_SendStr("\n\r");
          UART_SendStr("0x");
          UART_SendHex16(example.save);
          UART_SendStr("\n\r");
          UART_SendStr(example.str);
          UART_SendStr("\n\r");
      }
      else
      {
          UART_SendStr("EEPROM read is failed!\n\r");
      }
  }
  else
  {
      UART_SendStr("EEPROM is not connected!\n\r");
  }
  }
  /* USER CODE END 2 */