rtthread：f1代码移植

本文开始移植rtthread的代码到正点原子的板子上；参考资料为野火的教程，需要搭配野火教程使用；

使用源码是作为pack包放在arm-keil官网下载的nano3.0.3版本；nano版本精简方便解构；gittee上的master版本组件又多又杂不利于初学；

本来想用3.1.5版本源码的，但是移植过程会有代码报错又莫名其妙好了，等3.0.3移植完后再试试吧；

在开始移植rtthread源码前，先看看rtthread源码的文件分布；

1 源码文件

  1.1 bsp：      rtthread移植好的厂商评估板的完整例程文件夹，以及board.c和rtconfig.h；保留board.c和rtconfig.h即可；

  1.2 components    RT-Thread 的各个组件代码，例如 finsh，gui 等；

  1.3 docs：      没啥；

  1.4 include：    RT-Thread 内核的头文件；

  1.5 libcpu：      arm架构和risc-v架构下各类的内核代码；复制用的那一个xx.s以及cpuport.c就可以了，多了报错；    

  1.6 src：      RT-Thread 内核的源文件；

2 代码修改

  board.c中systick相关都删掉，然后rt_hw_board_init()中改用SysTick_Config()函数；然后加个board.h头文件；

  rtconfig.h修改了栈空间为256->512，ststick参数的周期为100->1000；就修改完了rtthread源码配置；

  每次记录删删改改感觉太冗余了，之后每章节代码修改通过查看提交记录可知；

  rtthread_f1demo: 将rtthread nano3.0.3版本移植到stm32f1上； (gitee.com)

3 rt_kprintf()串口调试 

//rtthread.h中，这里是ifndef,不是ifdef;这个字符串的参数居然是用(...)，第一次见，先放着；
#ifndef RT_USING_CONSOLE
#define rt_kprintf(...)
#define rt_kputs(str)
#else
void rt_kprintf(const char *fmt, ...);     //定义了RT_USING_CONSOLE,所以执行的是这里的两个函数;
void rt_kputs(const char *str);
#endif

//if定义了RT_USING_DEVICE设备驱动，则使用设备函数；else使用rt_hw_console_output()函数;所以使用的是rt_hw_console_output()；
void rt_kprintf(const char *fmt, ...)
{
    va_list args;
    rt_size_t length;
    static char rt_log_buf[RT_CONSOLEBUF_SIZE];
 
    va_start(args, fmt);//1 这个函数也不知道啥用，先放着不管；
    /* the return value of vsnprintf is the number of bytes that would be
     * written to buffer had if the size of the buffer been sufficiently
     * large excluding the terminating null byte. If the output string
     * would be larger than the rt_log_buf, we have to adjust the output
     * length. */
    //2 这个rtthread的字符处理函数老是看不懂，之前那个rt_object对象的字符处理函数也是一样看不懂；先放着吧；
    length = rt_vsnprintf(rt_log_buf, sizeof(rt_log_buf) - 1, fmt, args);
    if (length > RT_CONSOLEBUF_SIZE - 1)
        length = RT_CONSOLEBUF_SIZE - 1;
#ifdef RT_USING_DEVICE
    if (_console_device == RT_NULL)
    {
        rt_hw_console_output(rt_log_buf);
    }
    else
    {
        rt_uint16_t old_flag = _console_device->open_flag;
 
        _console_device->open_flag |= RT_DEVICE_FLAG_STREAM;
        rt_device_write(_console_device, 0, rt_log_buf, length);
        _console_device->open_flag = old_flag;
    }
#else
    rt_hw_console_output(rt_log_buf);    //这个函数的弱声明也在kservice.c中，重写在board.c中;
#endif
    va_end(args);                        //3 这个函数也不知道啥用，先放着不管；
}
RTM_EXPORT(rt_kprintf);                  //4 这个函数也不知道啥用，先放着不管；
#endif
 
//rtdef.h  不知道啥用，先放着；
#define va_start(v,l)       __builtin_va_start(v,l)
#define va_end(v)           __builtin_va_end(v)

//使用usart1作为rt_kprintf() output,函数弱声明在kservice.c中;与单片机串口1的重定向并不冲突;
//这个函数是可以被打断的，通过静态变量rt_scheduler_lock_nest来统计嵌套的次数;
void rt_hw_console_output(const char *str)
{
    rt_enter_critical();
    //"..."字符串的数据末尾会自动添加 "\0" ,所以可以通过"\0"来判断字符串是否结尾;
    while (*str!='\0'){
        if (*str=='\n'){
            USART_SendData(USART1, '\r'); 
            while (!USART_GetFlagStatus(USART1, USART_FLAG_TXE))
                ;
        }
        USART_SendData(USART1, *str++); 				
        while (!USART_GetFlagStatus(USART1, USART_FLAG_TXE))
            ;	
    }	
    rt_exit_critical();
}

4 main函数扩展

  MDK编译器中当原函数已经封装成外部库函数不可修改，或者已经编码烧录在rom中的时候，可以通过标识符对原函数进行打补丁操作；

  在rtthread中使用其对main函数进行了补丁操作，扩展了main函数，在调用main函数之前先初始化了rtthread系统；

  4.1 函数补丁demo

    4.1.1 ￥Super$$：标识函数原型，目的是标识函数原型给编译器回调；（格式问题此处用￥代替了$，具体格式见代码；）

    4.1.2 ￥Sub$$：   标识函数原型的补丁函数，编译器会将补丁函数放到原型函数之前或之后执行；

    4.1.3 被标识函数及原型函数需要是全局函数或者弱声明函数，且被标识函数需要是代码编译的时候就编译好的静态链接，不能是实时执行的动态链接；想想也知道啦；

extern void ExtraFunc(void);    //补丁操作;
 
extern void $Super$$foo(void):
void $Sub$$foo(void)
{
    ExtraFunc();                //补丁操作;    
    $Super$$foo();              //通过调用$Super$$foo()去回调原函数;
                                
}

  4.2 函数扩展main( )

    以下为rtthread中main函数扩展的逻辑流程；

    那么问题来了，这个main_thread_entry( )函数是什么时候从优先级表中删除的呢？他要是没有从优先级表中移除那岂不是会一直调用main函数？

    这个问题先放着；

//components.c 在执行main函数之前会先调用$Sub$$main()函数，等会通过调用$Super$$main()函数回到main函数;
#if defined (__CC_ARM)
extern int $Super$$main(void);    //通过$Super$$来标识函数扩展函数原型是main函数;
 
int $Sub$$main(void)              //通过$Sub$$对main函数进行打补丁操作;
{
    rt_hw_interrupt_disable();
    rtthread_startup();
    return 0;
}
#elif defined(__ICCARM__)
//....
#elif defined(__GNUC__)
//...
#endif
 
 
 
//components.c 初始化了$Super$$main()函数所在线程，定时器线程，空闲线程，然后启动switch_to调度函数;
int rtthread_startup(void)
{
    rt_hw_interrupt_disable();
 
    rt_hw_board_init();            //NOTE: please initialize heap inside board initialization
    //rt_show_version();
    rt_system_timer_init();
    rt_system_scheduler_init();
 
#ifdef RT_USING_SIGNALS
    rt_system_signal_init();
#endif
 
    rt_application_init();            //main_thread_entry的节点放入优先级表中、悬起线程;
    rt_system_timer_thread_init();    //timer定时器初始化;
    rt_thread_idle_init();            //idle空闲线程初始化;
    rt_system_scheduler_start();      //启动调度函数switch_to汇编;
	
    /* never reach here */
    return 0;
}
 
 
//components.c
#ifndef RT_USING_HEAP
ALIGN(8)
static rt_uint8_t main_stack[RT_MAIN_THREAD_STACK_SIZE];
struct rt_thread main_thread;
#endif
 
void main_thread_entry(void *parameter)
{
    extern int main(void);
    extern int $Super$$main(void);
    rt_components_init();
#if defined (__CC_ARM)
    $Super$$main();        //回调执行main函数;
#elif defined(__ICCARM__) || defined(__GNUC__)
    main();
#endif
}

5 空闲线程

  空闲线程作为rtthread系统的资源回收线程，主要是作为线程的删除回收工作；空闲线程是唯一不允许阻塞运行的线程；

//idle.c   在补丁main函数中的idle初始化函数;
void rt_thread_idle_init(void)
{
    /* initialize thread */
    rt_thread_init(&idle,
                   "tidle",
                   rt_thread_idle_entry,
                   RT_NULL,
                   &rt_thread_stack[0],
                   sizeof(rt_thread_stack),
                   RT_THREAD_PRIORITY_MAX - 1,
                   32);
    /* startup */
    rt_thread_startup(&idle);
}
 
//idle.c   idle的线程函数;
static void rt_thread_idle_entry(void *parameter)
{
    while (1)
    {
#ifdef RT_USING_IDLE_HOOK
        if (rt_thread_idle_hook != RT_NULL)
        {
            rt_thread_idle_hook();
        }
#endif
        rt_thread_idle_excute();
    }
}

//idle.c   
//1:rt_list_remove(&thread->tlist);  2:rt_thread_exit();   3:如果是RT_Object_Class_State那么就不释放内存了；
//4: RT_KERNEL_FREE(栈);  5：rt_object_delete从容器中移除object_list，然后释放thread结构体内存；
void rt_thread_idle_excute(void)
{
    /* Loop until there is no dead thread. So one call to rt_thread_idle_excute
     * will do all the cleanups. */
    while (_has_defunct_thread())
    {
        rt_base_t lock;
        rt_thread_t thread;
#ifdef RT_USING_MODULE
        rt_module_t module = RT_NULL;
#endif
        RT_DEBUG_NOT_IN_INTERRUPT;
 
        /* disable interrupt */
        lock = rt_hw_interrupt_disable();
 
        /* re-check whether list is empty */
        if (_has_defunct_thread())
        {
            /* get defunct thread */
            thread = rt_list_entry(rt_thread_defunct.next,
                                   struct rt_thread,
                                   tlist);
#ifdef RT_USING_MODULE
            /* get thread's parent module */
            module = (rt_module_t)thread->module_id;
 
            /* if the thread is module's main thread */
            if (module != RT_NULL && module->module_thread == thread)
            {
                /* detach module's main thread */
                module->module_thread = RT_NULL;
            }
#endif
            /* remove defunct thread */
            rt_list_remove(&(thread->tlist));
 
            /* lock scheduler to prevent scheduling in cleanup function. */
            rt_enter_critical();
 
            /* invoke thread cleanup */
            if (thread->cleanup != RT_NULL)
                thread->cleanup(thread);
 
#ifdef RT_USING_SIGNALS
            rt_thread_free_sig(thread);
#endif
 
            /* if it's a system object, not delete it */
            if (rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE)
            {
                /* unlock scheduler */
                rt_exit_critical();
 
                /* enable interrupt */
                rt_hw_interrupt_enable(lock);
 
                return;
            }
 
            /* unlock scheduler */
            rt_exit_critical();
        }
        else
        {
            /* enable interrupt */
            rt_hw_interrupt_enable(lock);
 
            /* may the defunct thread list is removed by others, just return */
            return;
        }
 
        /* enable interrupt */
        rt_hw_interrupt_enable(lock);
 
#ifdef RT_USING_HEAP
#if defined(RT_USING_MODULE) && defined(RT_USING_SLAB)
        /* the thread belongs to an application module */
        if (thread->flags & RT_OBJECT_FLAG_MODULE)
            rt_module_free((rt_module_t)thread->module_id, thread->stack_addr);
        else
#endif
            /* release thread's stack */
            RT_KERNEL_FREE(thread->stack_addr);
        /* delete thread object */
        rt_object_delete((rt_object_t)thread);
#endif
 
#ifdef RT_USING_MODULE
        if (module != RT_NULL)
        {
            extern rt_err_t rt_module_destroy(rt_module_t module);
 
            /* if sub thread list and main thread are all empty */
            if ((module->module_thread == RT_NULL) &&
                rt_list_isempty(&module->module_object[RT_Object_Class_Thread].object_list))
            {
                module->nref --;
            }
 
            /* destroy module */
            if (module->nref == 0)
                rt_module_destroy(module);
        }
#endif
    }
}

6 小结

  至此，rtthread系统初始化完成，可以使用串口1调试，在main函数中创建线程，然后将线程挂载到优先级表后即可运行；

  所以那些线程能够一直存在是因为有循坏加阻塞延时；如果线程里没有循坏，执行完就被idle删除了，比如$Submain$$函数；

  rtthread_f1demo: 将rtthread nano3.0.3版本移植到stm32f1上； (gitee.com)