Эмуляция EEPROM на базе Flash-памяти микроконтроллеров STM32.

Очень часто возникает вопрос, связанный с использованием Flash-памяти микроконтроллеров STM32 в качестве EEPROM. И в этой статье рассмотрим один из вариантов эмуляции памяти EEPROM.

Итак, в чем изначально заключается проблема, и почему нельзя просто выделить сектор/страницу во Flash и использовать ее? Ответ, по большому счету, кроется в трех словах - количество циклов перезаписи. Для Flash максимально допустимое число на порядки меньше, чем для EEPROM, навскидку, 10000 циклов против 1000000.

Конечно, есть и другие отличия - скорость записи, чтения и т. д. Но упирается все именно в продолжительность жизни (что соответствует кол-ву циклов перезаписи).

Поэтому и возникает необходимость в программных алгоритмах, которые позволят искусственно увеличить это число для Flash-памяти микроконтроллера. Собственно, у ST есть целый application note, посвященный данному вопросу, более того с готовым примером кода. Так что, в принципе, можно спокойно использовать решение от производителя.

Но так получилось, что я начал править этот проект под себя и в итоге переделал все с нуля. Не буду судить, насколько это оказалось оправданно, просто распишу основные идеи, которые предлагает ST, и затем, как обычно, создадим пример для проверки работоспособности. И заодно разберем основные функции.

Первый ключевой аспект заключается в том, как будут храниться данные. Для каждой переменной существует определенное фиксированное значение - ключ. Выделим под ключ и под саму переменную по 4 байта. Допустим нам надо хранить во Flash значения трех переменных:

Непосредственно в памяти данные будут выглядеть так:

Для каждой переменной сохраняется пара ключ-значение.

А если нам потребуется обновить значение переменной data_2 на новое, к примеру - 0x4567, то мы просто записываем еще одну пару ключ-значение в свободное место памяти:

Получается, что для переменной data_2 сохранено два значения, при этом актуальным является второе, записанное позже. Но при этом первое не удаляется. Таким образом, значения переменных будут обновляться (записываться в свободные адреса) до тех пор, пока страница памяти не окажется полностью заполненной:

Далее в дело вступает второй ключевой аспект. Он заключается в использовании двух страниц Flash-памяти. По заполнению 1-ой страницы мы переносим данные из нее во 2-ую страницу. Но! Переносим не все значения подряд, а только актуальные, то есть записанные последними. И так для каждой переменной:

Заполняем 2-ую страницу этими величинами и очищаем страницу 1:

И далее все эти действия повторяются до тех пор, пока не заполнится и вторая страница, после чего они снова меняются местами.

Что это дает в итоге?

• В первую очередь, количество циклов перезаписи изначально увеличивается на порядки, поскольку мы не очищаем Flash каждый раз, когда нам нужно обновить значение одной переменной. Очистка происходит только по фактическому заполнению страницы.
• Кроме того, мы используем две страницы, что позволяет распределить эти циклы перезаписи между ними.

Для того, чтобы идентифицировать, в каком состоянии находятся страницы Flash-памяти, которые мы используем, добавим в начальные адреса каждой из них ее статус:

В итоге первые 4 байта у нас заняты текущим статусом страницы. Поскольку для каждого значения переменной суммарно у нас используются 8 байт, то добавим смещение еще на 4 байта относительно начала страницы (для удобства). Результат будет таким:

Жизнедеятельность страниц может выглядеть так:

И здесь мы получаем еще один бонус от использование нескольких страниц. Рассмотрим такую ситуацию - 1-я страница заполнена и начинается копирование ее данных во 2-ю страницу. И в середине этого процесса возникает сбой питания, и процесс обрывается. После устранения проблемы и включения платы первая страница окажется в состоянии Active, а вторая - в состоянии Cleared. Что просто приведет к повторной попытке переноса данных, то есть данные не утеряны, а по-прежнему спокойно себе лежат в странице 1.

А если бы у нас была только одна страница, то по ее заполнению нам нужно было бы перенести данные в некий массив в оперативной памяти (RAM) контроллера, чтобы затем очистить страницу и обновить ее же из этого массива (оставив таким образом только актуальные, то есть последние, значения переменных). Так вот при обрыве питания в момент, когда страница уже очищена, а данные еще в RAM, они были бы безвозвратно потеряны.

Итак, возвращаемся к эмуляции EEPROM и теперь бегло рассмотрим конкретные функции, которые все это реализуют.

Все функции возвращают одно из значений:

typedef enum {
	EEPROM_OK = 0,
	EEPROM_ERROR = 1,
} EepromResult;

Для части функций просто рассмотрим их назначение, а некоторые разберем подробнее, если это важно для понимания сути процессов.

• EepromResult EEPROM_ClearPage(PageIdx idx). Производит очистку страницы, номер которой передан в качестве аргумента.
• EepromResult EEPROM_CopyPageData(PageIdx oldPage, PageIdx newPage). Копирует содержимое страницы oldPage в newPage. При этом обновляет статусы обеих страниц по результатам копирования/очистки.
• EepromResult EEPROM_Format(). Полная очистка EEPROM - то есть очистка страниц Flash, которые используются для эмуляции EEPROM.
• EepromResult EEPROM_GetActivePageIdx(PageIdx *idx). Позволяет определить номер активной страницы.
• EepromResult EEPROM_Init(). Функция инициализации, на ней как раз и остановимся подробнее.

EepromResult EEPROM_Init()
{
	EepromResult res = EEPROM_OK;
	PageState pageStates[PAGES_NUM];

	for (uint8_t i = 0; i < PAGES_NUM; i++)
	{
		pageStates[i] = EEPROM_ReadPageState((PageIdx)i);
	}
	
	if (((pageStates[PAGE_0] == PAGE_CLEARED) && (pageStates[PAGE_1] == PAGE_CLEARED)) ||
		((pageStates[PAGE_0] == PAGE_ACTIVE) && (pageStates[PAGE_1] == PAGE_ACTIVE)) || 
		((pageStates[PAGE_0] == PAGE_RECEIVING_DATA) && (pageStates[PAGE_1] == PAGE_RECEIVING_DATA)))
	{
		res = EEPROM_Format();
		
		if (res != EEPROM_OK)
		{
			return res;
		}
	
		res = EEPROM_SetPageState(PAGE_0, PAGE_ACTIVE);
	}
	
	if ((pageStates[PAGE_0] == PAGE_RECEIVING_DATA) && (pageStates[PAGE_1] == PAGE_CLEARED))
	{
		res = EEPROM_SetPageState(PAGE_0, PAGE_ACTIVE);
	}
	
	if ((pageStates[PAGE_0] == PAGE_CLEARED) && (pageStates[PAGE_1] == PAGE_RECEIVING_DATA))
	{
		res = EEPROM_SetPageState(PAGE_1, PAGE_ACTIVE);
	}
	
	if ((pageStates[PAGE_0] == PAGE_RECEIVING_DATA) && (pageStates[PAGE_1] == PAGE_ACTIVE))
	{
		res = EEPROM_CopyPageData(PAGE_1, PAGE_0);
	}
	
	if ((pageStates[PAGE_0] == PAGE_ACTIVE) && (pageStates[PAGE_1] == PAGE_RECEIVING_DATA))
	{
		res = EEPROM_CopyPageData(PAGE_0, PAGE_1);
	}
	
	return res;
}

Здесь мы пробегаем по возможным комбинациям состояний страниц. Если статус страниц совпадает, то это сигнализирует об ошибке, форматируем память полностью и начинаем с чистого листа:

if (((pageStates[PAGE_0] == PAGE_CLEARED) && (pageStates[PAGE_1] == PAGE_CLEARED)) ||
	((pageStates[PAGE_0] == PAGE_ACTIVE) && (pageStates[PAGE_1] == PAGE_ACTIVE)) || 
	((pageStates[PAGE_0] == PAGE_RECEIVING_DATA) && (pageStates[PAGE_1] == PAGE_RECEIVING_DATA)))
{
	res = EEPROM_Format();
	
	if (res != EEPROM_OK)
	{
	return res;
	}

	res = EEPROM_SetPageState(PAGE_0, PAGE_ACTIVE);
}

Если каким-то образом случилось так, что одна страница в состоянии Receiving Data, а вторая очищена - Cleared, то лучшее из того, что мы можем предпринять, это сделать 1-ую из них активной, поскольку в ней по сравнению со 2-ой явно хранятся какие-то полезные данные:

if ((pageStates[PAGE_0] == PAGE_RECEIVING_DATA) && (pageStates[PAGE_1] == PAGE_CLEARED))
{
	res = EEPROM_SetPageState(PAGE_0, PAGE_ACTIVE);
}

if ((pageStates[PAGE_0] == PAGE_CLEARED) && (pageStates[PAGE_1] == PAGE_RECEIVING_DATA))
{
	res = EEPROM_SetPageState(PAGE_1, PAGE_ACTIVE);
}

И, наконец, ситуация, когда одна из страниц - Receiving Data, а вторая - Active, как раз соответствует рассмотренному нами случаю с обрывом питания. Повторяем операцию копирования:

if ((pageStates[PAGE_0] == PAGE_RECEIVING_DATA) && (pageStates[PAGE_1] == PAGE_ACTIVE))
{
	res = EEPROM_CopyPageData(PAGE_1, PAGE_0);
}

if ((pageStates[PAGE_0] == PAGE_ACTIVE) && (pageStates[PAGE_1] == PAGE_RECEIVING_DATA))
{
	res = EEPROM_CopyPageData(PAGE_0, PAGE_1);
}

Идем дальше по функциям:

• EepromResult EEPROM_PageTransfer(PageIdx activePage, uint32_t varId, uint32_t varValue). Выполняет перенос актуальных данных из одной страницы в другую, кроме того в новую страницу добавляет пару ключ - значение, переданную через аргументы (varId / varValue). Осуществляется это так:
  • Записываем упомянутые данные из аргументов: varId / varValue.
  • Проходим по всему списку ключей и для каждого находим актуальное значение, которое и пишем в новую страницу.
  • Стираем старую страницу.

• Функции управления состоянием страницы:
  • PageState EEPROM_ReadPageState(PageIdx idx)
  • EepromResult EEPROM_SetPageState(PageIdx idx, PageState state).
• И напоследок осталось самое интересное - чтение и запись данных.

Код функции записи:

EepromResult EEPROM_Write(uint32_t varId, uint32_t varValue)
{
	EepromResult res = EEPROM_OK;
	
	uint8_t validId = 0;
	for (uint32_t curVar = 0; curVar < VAR_NUM; curVar++)
	{
		if (varIdList[curVar] == varId)
		{
			validId = 1;
			break;
		}
	}
	
	if (validId == 0)
	{
		res = EEPROM_ERROR;
		return res;
	}
	
	PageIdx activePage = PAGE_0;
	res = EEPROM_GetActivePageIdx(&activePage);
	
	if (res != EEPROM_OK)
	{
		return res;
	}
	
	uint32_t startAddr = pageAddress[activePage] + PAGE_DATA_OFFSET;
	uint32_t endAddr = pageAddress[activePage] + PAGE_SIZE - PAGE_DATA_SIZE;
	uint32_t addr = startAddr;
	
	uint8_t freeSpaceFound = 0;
	
	while (addr <= endAddr)
	{
		uint32_t idData = FLASH_Read(addr);
		if (idData == 0xFFFFFFFF)
		{
			freeSpaceFound = 1;
			break;
		}
		else
		{
			addr += PAGE_DATA_SIZE;
		}
	}
	
	if (freeSpaceFound == 1)
	{
		res = EEPROM_WriteData(addr, varId, varValue);
	}
	else
	{
		res = EEPROM_PageTransfer(activePage, varId, varValue);
	}
	
	return res;
}

Первым делом проверяем, что переданный в функцию ключ varId является валидным, то есть находится в списке допустимых ключей (этот момент мы разберем подробнее на практическом примере ниже).

Далее определяем номер активной страницы. Остается найти свободное место и записать туда новые данные. При поиске свободного места читаем данные, которые располагаются там, где должны быть ключи. Соответственно, по тому адресу, где на месте ключа значение 0xFFFFFFFF (ячейка памяти пуста), и производим запись.

Если же свободного места не обнаружено, то переходим к процессу переноса данных в другую страницу - EEPROM_PageTransfer().

И код для чтения данных:

EepromResult EEPROM_Read(uint32_t varId, uint32_t *varValue)
{
	EepromResult res = EEPROM_OK;
	
	PageIdx activePage = PAGE_0;
	res = EEPROM_GetActivePageIdx(&activePage);
	
	if (res != EEPROM_OK)
	{
		return res;
	}
	
	uint32_t startAddr = pageAddress[activePage] + PAGE_DATA_OFFSET;
	uint32_t endAddr = pageAddress[activePage] + PAGE_SIZE - PAGE_DATA_SIZE;
	uint32_t addr = endAddr;
	
	uint8_t dataFound = 0;
		
	while (addr >= startAddr)
	{
		uint32_t idData = FLASH_Read(addr);
		if (idData == varId)
		{
			dataFound = 1;
			*varValue = FLASH_Read(addr + 4);
			break;
		}
		else
		{
			addr -= PAGE_DATA_SIZE;
		}
	}
	
	if (dataFound == 0)
	{
		res = EEPROM_ERROR;
	}
	
	return res;
}

Находим номер активной страницы и начинаем поиск нужного нам ключа (varId) среди сохраненных в памяти. При этом в отличие от функции записи поиск ведем от конца страницы к началу, то есть в обратном направлении. Связано это с тем, что как мы уже разобрали в начале статьи, при обновлении значений для определенного ключа новые значения записываются в память последовательно. То есть среди всех значений с одним и тем же ключом актуальным будет последнее из них (которое ближе к концу страницы).

Вот и все, находим ключ, вычисляем адрес, где хранится значение (добавив смещение на длину ключа, равную 4 байтам) и читаем данные.

Переходим к практическому примеру использования - будем сохранять величины двух переменных, каждой из которых поставим в соответствие значение ключа.

В файле eeprom.h нам нужно выполнить конфигурацию эмулятора:

#define PARAM_1                                                         0x12121212
#define PARAM_2                                                         0x34343434
#define VAR_NUM                                                         2

• VAR_NUM - это количество ключей, а значит разных переменных, которые мы будем сохранять.
• Для каждого из этих ключей задаем значения: PARAM_1, PARAM_2.

В файле eeprom.c помещаем их в массив:

static uint32_t varIdList[VAR_NUM] = {PARAM_1, PARAM_2};

Помимо этого указываем адреса использующихся страниц. У меня для этого примера микроконтроллер STM32F103C8, и адресация Flash-памяти выглядит следующим образом:

Берем две последние страницы:

#define PAGE_0_ADDRESS                                                  0x0801F800
#define PAGE_1_ADDRESS                                                  0x0801FC00
#define PAGE_SIZE                                                       1024

И переходим в функцию main():

EEPROM_Init();

uint32_t readData[2] = {0, 0};

EEPROM_Write(PARAM_1, 0x1111);
EEPROM_Write(PARAM_2, 0x2222);

EEPROM_Read(PARAM_1, &readData[0]);
EEPROM_Read(PARAM_2, &readData[1]);

Инициализируем эмуляцию EEPROM, записываем значения для наших ключей и сразу же считываем их из памяти. Ожидаемо получаем:

И в Flash-памяти:

Обновим значение второго параметра и снова считаем:

  EEPROM_Write(PARAM_2, 0x3333);
  EEPROM_Read(PARAM_1, &readData[0]);
  EEPROM_Read(PARAM_2, &readData[1]);

Результат логичен:

И в памяти видим, что новое значение записалось в свободное место страницы, при этом и старое физически никуда не делось, хотя оно нам больше и не нужно:

Здесь мы просто передавали числа в функцию записи, соответственно, в общем случае там будут некие переменные:

EEPROM_Write(PARAM_1, var1);
EEPROM_Write(PARAM_2, var2);
// ...
EEPROM_Write(PARAM_2, var2);

Из ближайших доработок - необходимо добавить в записываемые данные контрольную сумму для проверки корректности сохраненных значений. Как вариант - сократить ключ на 4 байта и освободившееся место использовать под CRC. И на этом заканчиваем на сегодня - до скорого 🤝

Полный проект - MT_Eeprom.