STM32 и Дзен. Компиляция и запуск отдельных программ.

По просьбам трудящихся решил поделиться своими наработками.



Возможно, не все, описанное тут, будет правильным решением. Некоторые вещи я делал либо исходя из своих поверхностных представлений о том, как это должно работать, либо вообще по интуиции.
Если в комментариях кто-то отпишется, укажет на ошибки и посоветует более правильное решение — буду очень благодарен.
Может кого-то эта тема заинтересует, и совместными усилиями можно будет что-нибудь эдакое выдать, чтобы потом все желающие могли использовать.

Суть в следующем.
Имеется плата, на которой стоит микроконтроллер STM32 и, например, SD-карточка. Идеальный вариант, если есть SRAM, подключенный по FSMC, но не обязательно. Внутренней памяти, на первое время, хватит.

Что нужно: компилить в Keil (или, возможно, другой среде) программу, заливать ее на SD-карточку и запускать на контроллере.

Как будем запускать?
Сразу на ум приходят два очевидных варианта:
1) Если программа небольшая, в несколько килобайт — заливаем ее в RAM и оттуда запускаем.
2) Если программа побольше — предварительно ее переписываем во внутренний флеш и запускаем из него.

Ну а если программа занимает больше, чем свободно во внутреннем флеше, единственный выход — внешний RAM по FSMC.

В этой статье остановлюсь на первом варианте.

Этап первый. SD и FAT.

Подробно описывать не буду. На эту тему много всего написано как в инете, так и в этом сообществе.
SD-карточку можно подключить по SPI, можно по SDIO (если контроллер F103). И то и то есть в примерах стандартной периферийной библиотеки от ST.
Файловую систему легко поднять с помощью библиотеки FatFs. О ней, вроде, тоже были статьи.
И вообще, можно и без файловой системы обойтись, главное, чтобы можно было откуда-нибудь считать предварительно откомпиленную программу.

Этап второй. Подготовка проекта с программой.

В моем контроллере 64кб оперативы. Считаю, что «32 килобайта хватит каждому»: грузить будем по адресу 0x20008000 — половина RAM.
Нужно скомпилить проект так, чтобы все адреса были расчитаны исходя из этого адреса.



Обязательно делаем .hex — файл. Из него потом сделаем бинарник, который зальем на SD-карточку.



Также советую включить C Compiler Listing, чтобы можно было проконтролировать как код уложится.



Ставим галочку One ELF Section per Function, в дефайны добавляем тип контроллера:



Ну и напоследок, указываем базовый адрес и точку входа во вкладке Linker.



Ну и пишем код, наподобие этого:

#include "stm32f10x.h"
uint32_t _main(int argc, char *argv[], uint32_t core_addr)
{
    // что-нибудь тут делаем
    return 123;
}

Компилим, получаем .hex-файл.

Открываем .txt и .hex, смотрим чтобы _main обязательно был вначале:

                  _main PROC
;;;10     
;;;11     uint32_t _main(int argc, char *argv[], uint32_t core_addr)
000000  b570              PUSH     {r4-r6,lr}
;;;12     {
000002  4605              MOV      r5,r0
000004  460e              MOV      r6,r1
000006  4614              MOV      r4,r2
...

В .hex:

:020000042000DA
:1080000070B505460E4614460448046000F05AFA5E

Байты совпадают.

Этап третий. Получаем бинарник.

Лезем в интернет, разбираемся, что же за формат такой .hex:
http://ru.wikipedia.org/wiki/Intel_Hex

Находим спецификацию.

Чтобы перевести .hex в бинарник, воспользуемся вспомогательной программой. В инете они есть, но я предпочел за 5 минут наклепать свою, ибо нужна была уверенность, что все переведется так как мне нужно.
Можете ей воспользоваться на свой страх и риск, но учтите, что она сырая.
(скачать)



Можно заливать на карточку.

Этап четвертый. Собственно, запуск.

// указатель на функцию, с теми же аргументами, что и _main
uint32_t (*program)(int argc, char *argv[], uint32_t core);
...
program = (int(*)(int, char **))0x20008001; 
// Вот тут обратите внимание на адрес. Запускать надо не с 0x...00, а с 0x...01
// Кто может грамотно объяснить почему так, отпишитесь в комментариях. Я это понимаю лишь интуитивно: первая команда
// два байта занимает, а адрес команды, видимо, идет с последнего байта команды.
...
// адрес, куда будем заливать программу
uint8_t *addr;
addr = (uint8_t *)0x20008000;
...
// чтение из файла средствами FatFs
for (j = 0;;)
{
    res = f_read(&prog, buff, sizeof(buff), &br);    
    for(i = 0; i< br; i++)
    {
        addr[i+j] = buff[i];
    }
    j += br;
    if (res || br == 0) break; // error or eof 
}

...
// Собственно, запуск
retval = (*program)(argc-1, argv + 1, (uint32_t)CORE);

Этап пятый. Ядро.

Ну запустили мы какую-то функцию из отдельного файла куда-то в память. И что дальше?
Нам же надо работать с периферией!
Можно опять прикрутить к проекту с программой стандартную периферийную библиотеку и возить с собой уйму платформозависимого кода.

Я предлагаю такое решение. Сделать таблицу с адресами функций, которые будем предоставлять пользовательским программам. Эдакое ядро, что-ли.
Адрес этой таблицы передавать пользовательской программе. Например так:

typedef struct _corefunc
{
		uint16_t	index;
		uint32_t	addr;
		const char	*desc;
} corefunc;

Ну и, для примера, заполним эту табличку:

corefunc CORE[] =
{
	{ 0, (uint32_t)&fputc, "fputc" },
	{ 1, (uint32_t)&LED_GetState, "LED_GetState" },
	{ 2, (uint32_t)&LED_GetBlinkState, "LED_GetBlinkState" },
	{ 3, (uint32_t)&LED_On, "LED_On" },
	{ 4, (uint32_t)&LED_Off, "LED_Off" },
	{ 5, (uint32_t)&LED_OnBlink, "LED_OnBlink" },
	{ 6, (uint32_t)0, "" },
};

В первую очередь передадим программе наше переопределение fputc, чтобы та могла использовать printf для вывода.
Ну и, для разнообразия, добавим подержку светодиодов из моей статьи про USB.

Адрес этой таблички мы уже передали в программу выше (см. uint32_t core_addr)
Теперь надо что-то с этой табличкой сделать.

uint32_t _main(int argc, char *argv[], uint32_t core_addr)
{
	_CORE = (corefunc *)core_addr;
	unwrap_core();
	return _pmain(argc, argv);
}

...

void unwrap_core()
{
    fputc_ = (int(*)(int,FILE *))_CORE[0].addr;	
    LED_GetState_ = (uint8_t (*)(int))_CORE[1].addr;	
...
// и т.д.
}

...

int fputc(int ch, FILE *f)
{
	return (*fputc_)(ch, f);
}

uint8_t LED_GetState(int led)
{
	return (*LED_GetState_)(led);
}

...

// и т.д.

Ну и завершающий штрих — сама программа:

void print_core(void);

int _pmain(int argc, char *argv[])
{
	int i;
	printf("Hello from test program\r\n");
	for(i=0;i<argc;i++)
	{
		printf("Argument %d: %s\r\n", i, argv[i]);
	}

			
	print_core();	

	LED_OnBlink(2, 100, 100);
	return argc;
}

void print_core()
{
	int i;
	printf("Aviable core functions:\r\n");
	for(i=0;_CORE[i].addr != 0 && i<1024;i++)
	{
		printf("%d\t0x%x\t\t\t%s\r\n", _CORE[i].index, _CORE[i].addr, _CORE[i].desc);
	}
}

И небольшой скриншотик:

Велосипед изобретен.

Жду конструктивной и неконструктивной критики, а также обвинения в дилетантстве, в комментариях :)