ZiB

Первый проект.

Начитавшись форумов и глянув пару примеров, можно приступать к первому проекту.

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

Введение

В состав GCC входят компилятор и компоновщик (линкер), задача компилятора прочитать наш программный код и сформировать из них набор инструкций, которые компоновщик соберет в конечный выходной файл годный для заливки в МК.

Исходя из того нам нужно каким-то образом объяснить компоновщику как устроен наш МК, т.е. написать некий сценарий, т.е. указать сколько у нас флеш и ОЗУ, по каким адресам расположены, а так же указать куда что «положить».

Кроме того нужно выполнить начальную инициализацию МК. Почему эти действия не заложены на автомате как например в AVR-GCC, я думаю из-за разных реализаций микроконтроллеров с ARM архитектурой.

Сценарий

Необходимый минимум информации который должен содержать сценарий:

• расположение и размер флеш и ОЗУ
• расположение кода, данных
• размер и расположение стека
• имя точки входа Первым делом указываем расположение и размер флеш и ОЗУ:

MEMORY
{
  flash (rx) : ORIGIN = 0x08000000, LENGTH = 128K
  ram (rwx) : ORIGIN = 0x20000000, LENGTH = 8K
}

Рассмотрим подробнее указание флеш-памяти:

Далее необходимо описать карту распределения памяти.

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

Вначале указываем расположение кода программы, таблицу векторов прерываний и данных (константы):

.text :
{
  . = ALIGN(4);
  KEEP(*(.interrupt_vector))
  *(.text)
  *(.text*)
  *(.rodata)
  *(.rodata*)
  . = ALIGN(4);
} > flash

Рассмотрим подробнее:

Далее небольшой нюанс, так как у нас в программе возможно будут использоваться переменные которые могут иметь начальные значение, то не плохо бы хранить эти значения во флеш, а так же вынести в отдельную секцию и при старте просто копировать значения из флеш-памяти в ОЗУ. Целесообразно расположить эти данные в конце используемого пространства флеш-памяти (замечу не в конце флеш-памяти, можно было бы и в конце, но тогда бы пришлось прошивать данные в разные места флеш-памяти что согласитесь не очень удобно), для этого запомним последний используемый адрес флеш-памяти:

_data_flash = .;

Раннее я писал что оператор «точка» определяет текущий адрес.

И сразу опишем секцию:

.data : AT ( _data_flash )
{
  . = ALIGN(4);
  _data_begin = .;
  *(.data)
  *(.data*)
  . = ALIGN(4);
  _data_end = .;
} > ram

Так же для того что бы при старте знать что куда копировать «запоминаем» начальный и конечный адрес области (_data_begin, _data_end).

Аналогично задаем секцию для переменных начальные значение которых равны нулю (обнуляем их сами при старте):

.bss :
{
  _bss_begin = .;
  __bss_start__ = _bss_begin;
  *(.bss)
  *(.bss*)
  *(COMMON)
  . = ALIGN(4);
  _bss_end = .;
  __bss_end__ = _bss_end;
} > ram

Ну и последним этапом необходимо указать размер и расположение стека:

_stack_size = 200;
_stack_end = 0x20000000 + 8K;
_stack_begin = _stack_end - _stack_size;
. = _stack_begin;
._stack :
{
  . = . + _stack_size;
} > ram

Можно было бы не указывать размер стека, а просто задать указатель на конец ОЗУ, но тогда компоновщик не предупредить нас нам не хватить памяти под стек. (Если быть точным то мы указали не фиксированный размер и минимальный, так как реально данные как правило занимает не всю доступную область ОЗУ, а лишь часть и стек может иметь больший размер).

Осталось указать точку входа (адрес с которого начинается выполнение программы), в нашем случае при старте нам необходимо произвести инициализацию переменных, а уже потом переходить к основной программе:

ENTRY(handler_reset)

Что бы лучше понять распределение памяти я нарисовал вот такую схемку:

Инициализация

Осталось выполнить начальную инициализацию МК. Почему эти действия не заложены на автомате как например в AVR-GCC, я думаю из-за разных реализаций микроконтроллеров с ARM архитектурой.

Основные действия при инициализации:

• инициализация переменных
• указание стека
• передача управления основной программе

В примерах инициализация как правило написана на ассемблере, но что-то мне это не по душе и я переписал инициализацию на си, не знаю насколько корректно это сделал.

Инициализируем переменные начальными значениями и выполняем переход в основную программу:

void handler_reset(void)
{
  unsigned long *source;
  unsigned long *destination;

  // копируем данные из флеки в память
  source = amp;_data_flash;
  for(destination = amp;_data_begin; destination < amp;_data_end; )
  {
    *(destination++) = *(source++);
  }

  // обнуляем
  for(destination = amp;_bss_begin; destination < amp;_bss_end; )
  {
    *(destination++) = 0;
  }

  // переход в основную программу
  main();
}

Со стеком интереснее, достаточно просто записать в начальный адрес флеш-памяти указатель на конец стека, а так как сразу после этого идет таблица прерываний, то удобнее описать все за одно “движение”:

__attribute__ ((section(".interrupt_vector")))
void (* const table_interrupt_vector[])(void) =
{
		(void *) &_stack_end, // 0 - stack
		handler_reset, // 1
		handler_default, // 2
		handler_default, // 3
		handler_default, // 4
		handler_default, // 5
		handler_default, // 6
		0, // 7
		0, // 8
		0, // 9
		0, // 10
		handler_default, // 11
		handler_default, // 12
		0, // 13
		handler_default, // 14
		handler_default, // 15
		// периферия
		handler_default, // 0
		handler_default, // 1
		handler_default, // 2
		handler_default, // 3
		handler_default, // 4
		handler_default, // 5
		handler_default, // 6
		handler_default, // 7
		handler_default, // 8
		handler_default, // 9
		handler_default, // 10
		handler_default, // 11
		handler_default, // 12
		handler_default, // 13
		handler_default, // 14
		handler_default, // 15
		handler_default, // 16
		handler_default, // 17
		handler_default, // 18
		handler_default, // 19
		handler_default, // 20
		handler_default, // 21
		handler_default, // 22
		handler_default, // 23
		handler_default, // 24
		handler_default, // 25
		handler_default, // 26
		handler_default, // 27
		handler_default, // 28
		handler_default, // 29
		handler_default, // 30
		handler_default, // 31
		handler_default, // 32
		handler_default, // 33
		handler_default, // 34
		handler_default, // 35
		handler_default, // 36
		handler_default, // 37
		handler_default, // 38
		handler_default, // 39
		handler_default, // 40
		handler_default, // 41
		handler_default, // 42
		handler_default, // 43
		handler_default, // 44
		handler_default, // 45
		handler_default, // 46
		handler_default, // 47
		handler_default, // 48
		handler_default, // 49
		handler_default, // 50
		handler_default, // 51
		handler_default, // 52
		handler_default, // 53
		handler_default, // 54
		handler_default, // 55
		handler_default, // 56
		handler_default, // 57
		handler_default, // 58
		handler_default, // 59
		handler_default // 60
};

Атрибут ((section(“.interrupt_vector”))) предписываем компоновщику расположить данную таблицу в секции «interrupt_vector».

С векторами сильно не мудрил взял документацию на МК, посмотрел таблицу прерываний и на место каждого прерывания воткнул заглушку:

void handler_default(void)
{
	while (1)
	{

	}
}

продолжение следует…