RT-thread 用宏进行自动初始化

　　摘要：rt-thread 有一个机制是在main函数在运行已经将外设和组件自动用宏INIT_EXPORT(fn, level)初始化外设，接下来就要分析一下原理并模仿这种自动化初始化机制自己实现。

　　实现原理：1.将初始化函数注册到自定义的段中，然后分层级自动初始化设备

　　　　　　　2.$sub$$main $supur$$main  在main运行之前实现自动初始。  

具体实现可以参考文章：https://www.cnblogs.com/King-Gentleman/p/4570559.html

在这里贴一下自己实现的代码（MDK）：

#include "init.h"
#if 0
static init_func_t *init_list_begin;
static init_func_t *init_list_end;

void sys_init(void)
{
    init_func_t *index;
#if defined(__CC_ARM) || defined(__CLANG_ARM) 
    extern const int INIT_LIST$$Base;   
    extern const int INIT_LIST$$Limit;
    init_list_begin = (init_func_t *)&INIT_LIST$$Base;   //获得段起始地址
    init_list_end   = (init_func_t *)&INIT_LIST$$Limit;  //获得结束段地址
#elif defined(__ICCARM__)                      /* IAR ARMCC Complier */

#elif defined(__GNUC__)                        /* GNUC Complier */

#endif
    for(index = init_list_begin; index < init_list_end; index++)
    {
        index->_init_func();
    }
}
#else




#ifdef RT_USING_COMPONENTS_INIT
/*
 * Components Initialization will initialize some driver and components as following
 * order:
 * rti_start         --> 0
 * rti_board_start   --> 0.end
 * BOARD_EXPORT      --> 1
 * rti_board_end     --> 1.end
 *
 * DEVICE_EXPORT     --> 2
 * COMPONENT_EXPORT  --> 3
 * FS_EXPORT         --> 4
 * ENV_EXPORT        --> 5
 * APP_EXPORT        --> 6
 *
 * rti_end           --> 6.end
 *
 * These automatically initialization, the driver or component initial function must
 * be defined with:
 * INIT_BOARD_EXPORT(fn);
 * INIT_DEVICE_EXPORT(fn);
 * ...
 * INIT_APP_EXPORT(fn);
 * etc.
 */
static int rti_start(void)
{
    return 0;
}
INIT_EXPORT(rti_start, "0");

static int rti_board_start(void)
{
    return 0;
}
INIT_EXPORT(rti_board_start, "0.end");

static int rti_board_end(void)
{
    return 0;
}
INIT_EXPORT(rti_board_end, "1.end");

static int rti_end(void)
{
    return 0;
}
INIT_EXPORT(rti_end, "6.end");

/**
 * RT-Thread Components Initialization for board
 */
void components_board_init(void)
{
#if RT_DEBUG_INIT
    int result;
    const struct rt_init_desc *desc;
    Printk(RT_DEBUG_INIT,("do components board initialization.
"));
    for (desc = &__rt_init_desc_rti_board_start; desc < &__rt_init_desc_rti_board_end; desc ++)
    {     
        result = desc->fn();
        Printk(RT_DEBUG_INIT,(" %s init..,return code:%d 
", desc->fn_name,result)); 
    }
#else
    volatile const init_fn_t *fn_ptr;

    for (fn_ptr = &__rt_init_rti_board_start; fn_ptr < &__rt_init_rti_board_end; fn_ptr++)
    {
        (*fn_ptr)();
    }
#endif
}

/**
 * Thread Components Initialization
 */
void components_init(void)
{
#if RT_DEBUG_INIT
    int result;
    const struct rt_init_desc *desc;

    Printk(RT_DEBUG_INIT,("do components initialization.
"));
    for (desc = &__rt_init_desc_rti_board_end; desc < &__rt_init_desc_rti_end; desc ++)
    {
        result = desc->fn();
        Printk(RT_DEBUG_INIT,("%s init..,return code:%d 
", desc->fn_name,result));
    }
#else
    volatile const init_fn_t *fn_ptr;

    for (fn_ptr = &__rt_init_rti_board_end; fn_ptr < &__rt_init_rti_end; fn_ptr ++)
    {
        (*fn_ptr)();
    }
#endif
}
#endif   /* RT_USING_COMPONENTS_INIT */

#endif

typedef int (*init_fn_t)(void);

#if RT_DEBUG_INIT
    struct rt_init_desc
    {
        const char* fn_name;
        const init_fn_t fn;
    };
    #define INIT_EXPORT(fn, level)                                                       
        const char __rti_##fn##_name[] = #fn;                                            
        RT_USED const struct rt_init_desc __rt_init_desc_##fn SECTION(".init_fn." level) = 
        { __rti_##fn##_name, fn};
#else
    #define INIT_EXPORT(fn, level)                                                       
        RT_USED const init_fn_t __rt_init_##fn SECTION(".rti_fn." level) = fn
#endif


/* board init routines will be called in board_init() function */
#define INIT_BOARD_EXPORT(fn)           INIT_EXPORT(fn, "1")

/* pre/device/component/env/app init routines will be called in init_thread */
/* components pre-initialization (pure software initilization) */
#define INIT_PREV_EXPORT(fn)            INIT_EXPORT(fn, "2")
/* device initialization */
#define INIT_DEVICE_EXPORT(fn)          INIT_EXPORT(fn, "3")
/* components initialization (dfs, lwip, ...) */
#define INIT_COMPONENT_EXPORT(fn)       INIT_EXPORT(fn, "4")
/* environment initialization (mount disk, ...) */
#define INIT_ENV_EXPORT(fn)             INIT_EXPORT(fn, "5")
/* appliation initialization (gui application etc ...) */
#define INIT_APP_EXPORT(fn)             INIT_EXPORT(fn, "6")



void components_board_init(void);
void components_init(void);

void show_version(void)
{
    Printk(SYSTERM_INFO_DEBUG,("
 \ | /
"));
    Printk(SYSTERM_INFO_DEBUG,("- ST -     Thread Operating System
"));
    Printk(SYSTERM_INFO_DEBUG,(" / | \     %s.%s.%d build %s
",
               PCB_VERSION, SW_VERSION, APP_OPTIONS, __DATE__));
    Printk(SYSTERM_INFO_DEBUG,(" 2020 - 2020 Copyright by ST team
"));
}


int hw_board_init(void)
{
    __set_PRIMASK(0);
    SystemCoreClockUpdate();
    __set_PRIMASK(1);

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);

    /* all usart initlization */
    usart_Initialize_all();
    
#ifdef LOGDEBUG_TTL_USART_INDEX
    usart_Initialize(LOGDEBUG_TTL_USART_INDEX,LogUsartRcvCB);
#endif   
    
    /* show Thread version */
     show_version();

    TimerInitialize(CYCLE_TASK_TIMER_INDEX,CycleTask);
    


    
    components_board_init();
    
    return ARM_EOK;
}


 void main_thread_entry( void )
 {
     extern int main(void);
     extern int $Super$$main(void);
    
     components_init();
     
     $Super$$main();    /* 代指main函数 */
     
     
 }

int application_init(void)
{
    bool bRet = false;    
    static    TaskHandle_t xGeneralTaskHandle = NULL;
    if(NULL == xGeneralTaskHandle)
    {
        bRet = xTaskCreate((TaskFunction_t)main_thread_entry,(const char*)"main task",configMINIMAL_STACK_SIZE * 10,NULL,(UBaseType_t)1,(TaskHandle_t*)&xGeneralTaskHandle);
        if(bRet != NULL)
        {
            
        }
    }
    return bRet;
}

int thread_startup(void)
{
     /* board level initialization
     * NOTE: please initialize heap inside board initialization.
     */
     hw_board_init();

    /* create init_thread */
     application_init();

    /* start scheduler */
     vTaskStartScheduler();

    /* never reach here */
    return 0;
}

/* re-define main function */
int $Sub$$main(void)      /* 相当于补丁，在main函数之前运行的函数 */
{
    thread_startup();
    return 0;
}