rt-thread源码分析篇十四：rt_system_signal_init函数分析

最新推荐文章于 2022-05-12 23:30:33 发布
最新推荐文章于 2022-05-12 23:30:33 发布
阅读量516 收藏
点赞数
分类专栏： RT-Thread 文章标签： rtos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OnlyLove_/article/details/120148032
版权

零、在这里插入图片描述

函数调用

一、rt_system_signal_init源码

int rt_system_signal_init(void)
{
    _rt_siginfo_pool = rt_mp_create("signal", RT_SIG_INFO_MAX, sizeof(struct siginfo_node));
    if (_rt_siginfo_pool == RT_NULL)
    {
        dbg_log(DBG_ERROR, "create memory pool for signal info failed.\n");
        RT_ASSERT(0);
    }

    return 0;
}

二、rt_system_signal_init分析

1、siginfo_node结构整理

在这里插入图片描述

2、rt_mp_create分析

0、源码

rt_mp_t rt_mp_create(const char *name,			// "signal"
                     rt_size_t   block_count,	// RT_SIG_INFO_MAX
                     rt_size_t   block_size)	// sizeof(struct siginfo_node)
{
    rt_uint8_t *block_ptr;
    struct rt_mempool *mp;
    register rt_size_t offset;

    RT_DEBUG_NOT_IN_INTERRUPT;

    /* allocate object */
    mp = (struct rt_mempool *)rt_object_allocate(RT_Object_Class_MemPool, name);
    /* allocate object failed */
    if (mp == RT_NULL)
        return RT_NULL;

    /* initialize memory pool */
    block_size     = RT_ALIGN(block_size, RT_ALIGN_SIZE);
    mp->block_size = block_size;
    mp->size       = (block_size + sizeof(rt_uint8_t *)) * block_count;

    /* allocate memory */
    mp->start_address = rt_malloc((block_size + sizeof(rt_uint8_t *)) *
                                  block_count);
    if (mp->start_address == RT_NULL)
    {
        /* no memory, delete memory pool object */
        rt_object_delete(&(mp->parent));

        return RT_NULL;
    }

    mp->block_total_count = block_count;
    mp->block_free_count  = mp->block_total_count;

    /* initialize suspended thread list */
    rt_list_init(&(mp->suspend_thread));
    mp->suspend_thread_count = 0;

    /* initialize free block list */
    block_ptr = (rt_uint8_t *)mp->start_address;
    for (offset = 0; offset < mp->block_total_count; offset ++)
    {
        *(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *)))
            = block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *));
    }

    *(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *)))
        = RT_NULL;

    mp->block_list = block_ptr;

    return mp;
}
RTM_EXPORT(rt_mp_create);

1、rt_mempool结构整理

在这里插入图片描述

2、rt_object_allocate

// type - RT_Object_Class_MemPool
// name - "signal"
rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
{
    struct rt_object *object;
    register rt_base_t temp;
    struct rt_object_information *information;
#ifdef RT_USING_MODULE
    struct rt_dlmodule *module = dlmodule_self();
#endif

    RT_DEBUG_NOT_IN_INTERRUPT;

    /* get object information */
    information = rt_object_get_information(type);
    RT_ASSERT(information != RT_NULL);

    object = (struct rt_object *)RT_KERNEL_MALLOC(information->object_size);
    if (object == RT_NULL)
    {
        /* no memory can be allocated */
        return RT_NULL;
    }

    /* clean memory data of object */
    rt_memset(object, 0x0, information->object_size);

    /* initialize object's parameters */

    /* set object type */
    object->type = type;

    /* set object flag */
    object->flag = 0;

    /* copy name */
    rt_strncpy(object->name, name, RT_NAME_MAX);

    RT_OBJECT_HOOK_CALL(rt_object_attach_hook, (object));

    /* lock interrupt */
    temp = rt_hw_interrupt_disable();

#ifdef RT_USING_MODULE
    if (module)
    {
        rt_list_insert_after(&(module->object_list), &(object->list));
        object->module_id = (void *)module;
    }
    else
#endif
    {
        /* insert object into information object list */
        rt_list_insert_after(&(information->object_list), &(object->list));
    }

    /* unlock interrupt */
    rt_hw_interrupt_enable(temp);

    /* return object */
    return object;
}
1、rt_object_get_information
information = rt_object_get_information(type);

等价于

information = rt_object_get_information(RT_Object_Class_MemPool);

在这里插入图片描述

2、RT_KERNEL_MALLOC
#define RT_KERNEL_MALLOC(sz)            rt_malloc(sz)

void *rt_malloc(rt_size_t size)
{
    rt_size_t ptr, ptr2;
    struct heap_mem *mem, *mem2;

    RT_DEBUG_NOT_IN_INTERRUPT;

    if (size == 0)
        return RT_NULL;

    // RT_ALIGN - 返回指定宽度的最小尺寸
    if (size != RT_ALIGN(size, RT_ALIGN_SIZE))
        RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d, but align to %d\n",
                                    size, RT_ALIGN(size, RT_ALIGN_SIZE)));
    else
        RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d\n", size));

    /* alignment size */
    size = RT_ALIGN(size, RT_ALIGN_SIZE);

    // mem_size_aligned被初始化，初始值为SRAM可用空间
    if (size > mem_size_aligned)
    {
        RT_DEBUG_LOG(RT_DEBUG_MEM, ("no memory\n"));

        return RT_NULL;
    }

    // 分配内存最小值
    /* every data block must be at least MIN_SIZE_ALIGNED long */
    if (size < MIN_SIZE_ALIGNED)
        size = MIN_SIZE_ALIGNED;

    /* take memory semaphore */
    rt_sem_take(&heap_sem, RT_WAITING_FOREVER);

    // lfree等于heap_ptr，ptr表示使用的空间大小
    for (ptr = (rt_uint8_t *)lfree - heap_ptr;
         ptr < mem_size_aligned - size;
         ptr = ((struct heap_mem *)&heap_ptr[ptr])->next)
    {
        mem = (struct heap_mem *)&heap_ptr[ptr];

        // mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size表示分配以后，还可以再分配一个
        if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size)
        {
            /* mem is not used and at least perfect fit is possible:
             * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */

            // mem->next - (ptr + SIZEOF_STRUCT_MEM)代表分配以后剩余空间
            if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >=
                (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED))
            {
                /* (in addition to the above, we test if another struct heap_mem (SIZEOF_STRUCT_MEM) containing
                 * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')
                 * -> split large block, create empty remainder,
                 * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if
                 * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
                 * struct heap_mem would fit in but no data between mem2 and mem2->next
                 * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty
                 *       region that couldn't hold data, but when mem->next gets freed,
                 *       the 2 regions would be combined, resulting in more free memory
                 */
                ptr2 = ptr + SIZEOF_STRUCT_MEM + size;

                /* create mem2 struct */
                mem2       = (struct heap_mem *)&heap_ptr[ptr2];
                mem2->magic = HEAP_MAGIC;
                mem2->used = 0;
                mem2->next = mem->next;
                mem2->prev = ptr;
#ifdef RT_USING_MEMTRACE
                rt_mem_setname(mem2, "    ");
#endif

                /* and insert it between mem and mem->next */
                mem->next = ptr2;
                mem->used = 1;

                if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
                {
                    ((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
                }
#ifdef RT_MEM_STATS
                used_mem += (size + SIZEOF_STRUCT_MEM);
                if (max_mem < used_mem)
                    max_mem = used_mem;
#endif
            }
            else
            {
                /* (a mem2 struct does no fit into the user data space of mem and mem->next will always
                 * be used at this point: if not we have 2 unused structs in a row, plug_holes should have
                 * take care of this).
                 * -> near fit or excact fit: do not split, no mem2 creation
                 * also can't move mem->next directly behind mem, since mem->next
                 * will always be used at this point!
                 */
                mem->used = 1;
#ifdef RT_MEM_STATS
                used_mem += mem->next - ((rt_uint8_t *)mem - heap_ptr);
                if (max_mem < used_mem)
                    max_mem = used_mem;
#endif
            }
            /* set memory block magic */
            mem->magic = HEAP_MAGIC;
#ifdef RT_USING_MEMTRACE
            if (rt_thread_self())
                rt_mem_setname(mem, rt_thread_self()->name);
            else
                rt_mem_setname(mem, "NONE");
#endif

            if (mem == lfree)
            {
                /* Find next free block after mem and update lowest free pointer */
                while (lfree->used && lfree != heap_end)
                    lfree = (struct heap_mem *)&heap_ptr[lfree->next];

                RT_ASSERT(((lfree == heap_end) || (!lfree->used)));
            }

            rt_sem_release(&heap_sem);
            RT_ASSERT((rt_uint32_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uint32_t)heap_end);
            RT_ASSERT((rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
            RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE - 1)) == 0);

            RT_DEBUG_LOG(RT_DEBUG_MEM,
                         ("allocate memory at 0x%x, size: %d\n",
                          (rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM),
                          (rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));

            RT_OBJECT_HOOK_CALL(rt_malloc_hook,
                                (((void *)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM)), size));

            /* return the memory data except mem struct */
            return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM;
        }
    }

    rt_sem_release(&heap_sem);

    return RT_NULL;
}

作用：在堆上分配sizeof(struct rt_mempool)大小的空间。

0、rt_system_heap_init初始化后堆空间

在这里插入图片描述

1、RT_ALIGN
/**
 * @ingroup BasicDef
 *
 * @def RT_ALIGN(size, align)
 * Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4)
 * would return 16.
 */
#define RT_ALIGN(size, align)           (((size) + (align) - 1) & ~((align) - 1))

按指定字节进行对齐。

2、mem_size_aligned

堆总空间大小。
mem_size_aligned在rt_hw_board_init函数中的rt_system_heap_init初始化。

3、heap_sem

heap_sem在rt_hw_board_init函数中的rt_system_heap_init初始化。初始化后如下：
在这里插入图片描述

4、rt_sem_take

取内存信号量。

rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time)
{
    register rt_base_t temp;
    struct rt_thread *thread;

    /* parameter check */
    RT_ASSERT(sem != RT_NULL);
    RT_ASSERT(rt_object_get_type(&sem->parent.parent) == RT_Object_Class_Semaphore);

    RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(sem->parent.parent)));

    /* disable interrupt */
    temp = rt_hw_interrupt_disable();

    RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s take sem:%s, which value is: %d\n",
                                rt_thread_self()->name,
                                ((struct rt_object *)sem)->name,
                                sem->value));

    if (sem->value > 0)
    {
        /* semaphore is available */
        sem->value --;

        /* enable interrupt */
        rt_hw_interrupt_enable(temp);
    }
    else
    {
        /* no waiting, return with timeout */
        if (time == 0)
        {
            rt_hw_interrupt_enable(temp);

            return -RT_ETIMEOUT;
        }
        else
        {
            /* current context checking */
            RT_DEBUG_IN_THREAD_CONTEXT;

            /* semaphore is unavailable, push to suspend list */
            /* get current thread */
            thread = rt_thread_self();

            /* reset thread error number */
            thread->error = RT_EOK;

            RT_DEBUG_LOG(RT_DEBUG_IPC, ("sem take: suspend thread - %s\n",
                                        thread->name));

            /* suspend thread */
            rt_ipc_list_suspend(&(sem->parent.suspend_thread),
                                thread,
                                sem->parent.parent.flag);

            /* has waiting time, start thread timer */
            if (time > 0)
            {
                RT_DEBUG_LOG(RT_DEBUG_IPC, ("set thread:%s to timer list\n",
                                            thread->name));

                /* reset the timeout of thread timer and start it */
                rt_timer_control(&(thread->thread_timer),
                                 RT_TIMER_CTRL_SET_TIME,
                                 &time);
                rt_timer_start(&(thread->thread_timer));
            }

            /* enable interrupt */
            rt_hw_interrupt_enable(temp);

            /* do schedule */
            rt_schedule();

            if (thread->error != RT_EOK)
            {
                return thread->error;
            }
        }
    }

    RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(sem->parent.parent)));

    return RT_EOK;
}
RTM_EXPORT(rt_sem_take);

在这里插入图片描述
只更改value的值。

5、heap_ptr
static rt_uint8_t *heap_ptr;

heap_ptr在rt_hw_board_init函数中的rt_system_heap_init初始化。heap_ptr设置为堆开始的位置。

6、lfree
static struct heap_mem *lfree;

lfree在rt_hw_board_init函数中的rt_system_heap_init初始化。lfree设置为堆空闲位置。
注：rt_system_heap_init函数初始化后，heap_ptr和lfree相等。

7、size

size值等于sizeof(struct rt_mempool)。

8、SIZEOF_STRUCT_MEM
#define SIZEOF_STRUCT_MEM    RT_ALIGN(sizeof(struct heap_mem), RT_ALIGN_SIZE)
9、used_mem、max_mem
static rt_size_t used_mem, max_mem;

used_mem：堆使用大小
max_mem：堆最大使用

10、分配内存空间并初始化
for (ptr = (rt_uint8_t *)lfree - heap_ptr;
     ptr < mem_size_aligned - size;
     ptr = ((struct heap_mem *)&heap_ptr[ptr])->next)

ptr = (rt_uint8_t *)lfree - heap_ptr：ptr保存堆使用空间大小.
ptr < mem_size_aligned - size：检测空间是否够分配
ptr = ((struct heap_mem *)&heap_ptr[ptr])->next：指向下一片分配的空间。

mem = (struct heap_mem *)&heap_ptr[ptr];

heap_ptr为unsigned char指针，ptr为使用空间大小，heap_ptr[ptr]为第一个未使用的空间。

if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size)

mem->used表示这片空间使用情况。0 表示未使用，1 表示已经使用。
堆空间初始化后将最后一片空间设置为已使用，初始化后mem->next保存最后一片空间的首地址。
mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size：判断剩余空间是否够分配SIZEOF_STRUCT_MEM和size。

if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >=
	(size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED))

除了要分配空间SIZEOF_STRUCT_MEM和size外，检测分配后是否大于SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED。

ptr2 = ptr + SIZEOF_STRUCT_MEM + size;

/* create mem2 struct */
mem2       = (struct heap_mem *)&heap_ptr[ptr2];
mem2->magic = HEAP_MAGIC;
mem2->used = 0;
mem2->next = mem->next;
mem2->prev = ptr;

ptr2：指向分配后的空闲首地址。
mem2：初始化首个空闲堆可分配空间。

mem->next = ptr2;
mem->used = 1;
used_mem += (size + SIZEOF_STRUCT_MEM);
if (max_mem < used_mem)
    max_mem = used_mem;
mem->magic = HEAP_MAGIC;

初始化分配的空间。

11、更新lfree指针
if (mem == lfree)
{
    /* Find next free block after mem and update lowest free pointer */
    while (lfree->used && lfree != heap_end)
        lfree = (struct heap_mem *)&heap_ptr[lfree->next];

    RT_ASSERT(((lfree == heap_end) || (!lfree->used)));
}
12、rt_sem_release
rt_err_t rt_sem_release(rt_sem_t sem)
{
    register rt_base_t temp;
    register rt_bool_t need_schedule;

    /* parameter check */
    RT_ASSERT(sem != RT_NULL);
    RT_ASSERT(rt_object_get_type(&sem->parent.parent) == RT_Object_Class_Semaphore);

    RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(sem->parent.parent)));

    need_schedule = RT_FALSE;

    /* disable interrupt */
    temp = rt_hw_interrupt_disable();

    RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s releases sem:%s, which value is: %d\n",
                                rt_thread_self()->name,
                                ((struct rt_object *)sem)->name,
                                sem->value));

    if (!rt_list_isempty(&sem->parent.suspend_thread))
    {
        /* resume the suspended thread */
        rt_ipc_list_resume(&(sem->parent.suspend_thread));
        need_schedule = RT_TRUE;
    }
    else
        sem->value ++; /* increase value */

    /* enable interrupt */
    rt_hw_interrupt_enable(temp);

    /* resume a thread, re-schedule */
    if (need_schedule == RT_TRUE)
        rt_schedule();

    return RT_EOK;
}
RTM_EXPORT(rt_sem_release);

检查是否有挂起的线程。
执行结果heap_sem.value值加1。

13、返回堆分配可用空间
return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM;
14、RT_KERNEL_MALLOC执行结果

RT_KERNEL_MALLOC执行完成后堆使用情况如下：
在这里插入图片描述

3、rt_memset
void *rt_memset(void *s, int c, rt_ubase_t count)
{
#ifdef RT_USING_TINY_SIZE
    char *xs = (char *)s;

    while (count--)
        *xs++ = c;

    return s;
#else
#define LBLOCKSIZE      (sizeof(rt_int32_t))
#define UNALIGNED(X)    ((rt_int32_t)X & (LBLOCKSIZE - 1))
#define TOO_SMALL(LEN)  ((LEN) < LBLOCKSIZE)

    int i;
    char *m = (char *)s;
    rt_uint32_t buffer;
    rt_uint32_t *aligned_addr;
    rt_uint32_t d = c & 0xff;

    if (!TOO_SMALL(count) && !UNALIGNED(s))
    {
        /* If we get this far, we know that n is large and m is word-aligned. */
        aligned_addr = (rt_uint32_t *)s;

        /* Store D into each char sized location in BUFFER so that
         * we can set large blocks quickly.
         */
        if (LBLOCKSIZE == 4)
        {
            buffer = (d << 8) | d;
            buffer |= (buffer << 16);
        }
        else
        {
            buffer = 0;
            for (i = 0; i < LBLOCKSIZE; i ++)
                buffer = (buffer << 8) | d;
        }

        while (count >= LBLOCKSIZE * 4)
        {
            *aligned_addr++ = buffer;
            *aligned_addr++ = buffer;
            *aligned_addr++ = buffer;
            *aligned_addr++ = buffer;
            count -= 4 * LBLOCKSIZE;
        }

        while (count >= LBLOCKSIZE)
        {
            *aligned_addr++ = buffer;
            count -= LBLOCKSIZE;
        }

        /* Pick up the remainder with a bytewise loop. */
        m = (char *)aligned_addr;
    }

    while (count--)
    {
        *m++ = (char)d;
    }

    return s;

#undef LBLOCKSIZE
#undef UNALIGNED
#undef TOO_SMALL
#endif
}
RTM_EXPORT(rt_memset);

清除rt_mempool空间数据，全部设置为0。

4、为分配空间初始化rt_object对象
/* set object type */
object->type = type;

/* set object flag */
object->flag = 0;

/* copy name */
rt_strncpy(object->name, name, RT_NAME_MAX);
5、rt_list_insert_after

将分配空间插入到rt_object_information[RT_Object_Class_MemPool]中。
在这里插入图片描述

3、mp

mp为rt_object_allocate函数返回分配后空间地址。

4、初始化数据-1

/* initialize memory pool */
block_size     = RT_ALIGN(block_size, RT_ALIGN_SIZE);
mp->block_size = block_size;
mp->size       = (block_size + sizeof(rt_uint8_t *)) * block_count;

5、rt_malloc

mp->start_address = rt_malloc((block_size + sizeof(rt_uint8_t *)) *
                              block_count);

block_size：0x0000000C
block_count：0x00000020

6、初始化数据-2

mp->block_total_count = block_count;
mp->block_free_count  = mp->block_total_count;

/* initialize suspended thread list */
rt_list_init(&(mp->suspend_thread));
mp->suspend_thread_count = 0;

/* initialize free block list */
block_ptr = (rt_uint8_t *)mp->start_address;
for (offset = 0; offset < mp->block_total_count; offset ++)
{
    *(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *)))
        = block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *));
}

*(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *)))
    = RT_NULL;

mp->block_list = block_ptr;

3、rt_mp_create执行结果

rt_mp_create执行完成后，堆分配情况如下：
在这里插入图片描述
rt_object_information[RT_Object_Class_MemPool]链表如下：
在这里插入图片描述

lqonlylove
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RT-Thread常见函数.zip_RTT_rt thread_rt-thread函数_rt_thread函数_手册
09-24
《RT-Thread常见函数》是针对RT-Thread实时操作系统中常用函数的一份详细参考资料，旨在帮助开发者更好地理解和应用RTT的API。RT-Thread（简称RTT）是一款成熟、稳定且功能丰富的开源实时操作系统，广泛应用于物联网...
rtt相关问题总结
y673533511的博客
04-15 908
1、总结RT-Thread的启动流程。（启动文件部分跳过） /* 关中断 */ rt_hw_interrupt_disable(); /* 板级初始化：需在该函数内部进行系统堆的初始化 */ rt_hw_board_init(); /* 打印 RT-Thread 版本信息 */ rt_show_version(); /* 定时器初始化 */ ...
RT-Thread源码-1-启动流程剖析
qq_36535265的博客
04-30 457
本文参考代码为 RT-Thread Nano 3.1.3版本代码。在初始篇中仅针对此操作系统的初始化及启动流程进行分析。 不同的处理器系列及版本，以及使用的编译器之间会存在一些差别，但基本流程不变。 以Cortex-M4、GCC版本为例 初始化 从上电启动或复位重启，从栈顶初始化中断向量表后跳转到ResetHandler函数的栈地址，开始执行。 ResetHandler函数中： 跳转执行系统初始化SystemInit 跳转执行main函数，对RTOS进行初始化 启动 从main函数进入RT.
RT-Thread（一）--系统启动过程
FourLeafCloverLLLS的博客
05-01 4111
今天5月1号，趁着四天假期，我选择好好提升自己，打算这四天学习一个物联网操作系统，物联网时代的到来，mcu上的物联网操作系统，就变得尤为重要，上周在ST峰会上看到了阿里的著作，被深深的吸引住了。立下flag，一：好好学习英语 二：学习两门的物联网联网技术：蓝牙mesh和lora组网 三：学习一门物联网操作系统 四：接触物联网云平台搭建 。本来是想学习阿里的AliOS Things...
RTT移植STM32之创建进程
科技与思想的博客
06-24 1199
目录 1.RTT系统启动 2.创建自己的进程 1.RTT系统启动 RTT系统将main函数重定义在$Sub$$main(void)中，即程序运行顺序如下： LDR R0, =SystemInit BLX R0 LDR R0, =__main int $Sub$$main(void) { rt_hw_interrupt_d...
RT-Thread学习笔记一：（main的起始）系统启动代码
qq_41664309的博客
12-30 1749
//components.c 中定义 /* re-define main function */ int $Sub$$main(void) { rt_hw_interrupt_disable(); rtthread_startup(); return 0; } 1在这里$Sub$$main函数仅仅调用了rtthread_startup()函数。RT-Thread 支持多种平台和多种编译器，而rtthread_startup()函数是 RT-Thread 规定的统一入口...
rt-thread-3.1.3_rtthread_RT-Thread_nano_rtthreadopenocd_RT-Threa
09-30
RT-Thread是一个开源的实时操作系统（RTOS），专为嵌入式系统设计，具有高可靠性、低功耗和轻量级的特点。"rt-thread-3.1.3" 是该操作系统的特定版本，代表着该版本在功能和性能上的优化与改进。 RT-Thread Nano是...
rt-thread-master.zip_ARM thread_RT-Thread_RT_Thread_arm open sou
09-20
1. `include`：包含RT-Thread内核的头文件，定义了各种数据结构、常量和函数接口。 2. `kernel`：RT-Thread内核的核心代码，包括线程管理、内存管理、定时器、中断处理等模块。 3. `components`：包含了各种可选的...
rt-thread-v2.0.2.zip_RT-Thread_RT-thread-2_RT_Thread_V2 _rtthrea
09-24
这个"rt-thread-v2.0.2.zip"压缩包包含了RT-Thread的2.0.2版本源码，它是一个功能强大且高度可定制的内核，广泛应用于物联网设备、智能家居、工业控制等场景。RT-Thread的版本号"2.0.2"表示这是一个经过多次迭代和...
rt-thread-master-canopen.rar_RT-Thread_RT_Thread_beetoh_canopen_
07-13
RT-Thread是一个开源、中立、可信赖的物联网操作系统，具有高性能、低功耗、体积小、扩展丰富等特点。在本项目"rt-thread-master-canopen.rar"中，它被用于实现CANopen主站功能，这涉及到CANopen协议栈以及402子协议...
RTT启动流程
joe的博客
04-29 1631
一般了解一份代码大多从启动部分开始，同样这里也采用这种方式，先寻找启动的源头。以 MDKARM 为例， MDK-ARM 的用户程序入口为 main() 函数，位于 main.c 文件中。系统启动后先从汇编代码startup_stm32f103xe.s 开始运行，然后跳转到 C 代码，进行 RT-Thread 系统功能初始化，最后进入用户程序入口 main()。 为了在进...
RT_thread（一）系统的启动rtthread_startup
ljh5930的博客
05-12 1820
简单分析了rtthread系统的启动代码
【野火®】i.MX RT1052评测——移植RT-Thread
热门推荐
杰杰的博客
06-01 1万+
跨界处理器 i.MX RT1052是i.MX RT系列芯片，是由 NXP 半导体公司推出的跨界处理器芯片，该系列下又包括i.MX RT1020、i.MX RT1050及 i.MX RT1060等子系列芯片。所谓“跨界”，是指它自身的定位既非传统的应用处理器也非传统的微控制器。 传统的应用处理器如手机主控芯片，它们通常采用 ARM 的 Cortex-A系列内核，配合 其芯片架构...
RT-Thread 源码浏览笔记-内核启动
夏夕的博客
08-20 564
参考官方文档https://www.rt-thread.org/document/site/programming-manual/basic/basic/ 实时内核的实现包括：对象管理、线程管理及调度器、线程间通信管理、时钟管理及内存管理等等，内核最小的资源占用情况是 3KB ROM，1.2KB RAM。 RT-Thread 启动流程 官方文档中的启动流程 RT-Thread支持...
RTTheard学习笔记-内核启动流程
suny1234的博客
02-03 965
1111
源码解读·RT-Thread操作系统从开机到关机
detian5198的博客
07-10 612
本篇内容比较简单，但却很繁琐，篇幅也很长，毕竟是囊括了整个操作系统的生命周期。这篇文章的目的是作为后续设计多任务开发的铺垫，后续会单独再抽出一篇分析任务的相关知识。另外本篇文章以单核MCU为背景，并且以最新的3.1.xLTS版本源码进行分析。主要内容目录如下： 基于bsp/stm32/stm32f103-mini-system为背景 Cortex-M3的堆栈基础概念 ...
RT-Thread入门学习笔记
weixin_45596239的博客
03-16 327
第一章 初识RT-Thread RT-Thread小贴士： RT-Thread诞生于2006年，一款知名度高、口碑极佳、高度稳定可靠的实时操作系统。 RT-Thread是开源免费的，许可证类似FreeRTOS。并且，它不仅是一个RTOS内核，而且包含网络、文件系统、GUI界面等组件，具有极强的扩展性哟~ RT-Thread支持市面所有的主流编译工具（IAR、GCC、Keil等），硬件上，可支持完成超过50款MCU芯片上和所有主流CPU架构上的移植工作。 RT-Thread特点：高可靠性+组建丰富
rt-thread源码分析篇十五：rt_application_init函数分析
OnlyLove_的博客
09-08 1405
一、rt_application_init函数调用 二、函数分析 void rt_application_init(void) { rt_thread_t tid; #ifdef RT_USING_HEAP tid = rt_thread_create("main", main_thread_entry, RT_NULL, RT_MAIN_THREAD_STACK_SIZE, RT_MAIN_THREAD_PRIORITY, 20);
ARM 编译器 C 库启动和初始化
LIAOYUANGANG的博客
04-29 2428
1 介绍 本文档描述了 C 库启动代码和在使用 ARM 编译器编译的应用程序启动期间可能调用的初始化函数。该文档概述了启动代码中的功能的作用以及它们存在的原因。您可以使用此文档来验证您的应用程序的启动代码。 1.1 版本 本文档描述了 ARM 编译器的启动代码。启动代码中的函数可能会在工具链的不同版本和补丁之间发生变化。本文档不保证库启动代码在后续版本或工具链补丁中的持续运行。 1.2 补充阅读 本节列出了 ARM 和第三方的出版物。请参阅 Infocenter，http://infoce
realthread.rt-thread::rtos:kernel:3.1.5安装包
最新发布
01-17
realthread.rt-thread::rtos:kernel:3.1.5是一个用于实时操作系统开发的安装包。该安装包包含了一个高效的实时操作系统内核，可以用于嵌入式系统和物联网设备的开发。安装包提供了丰富的功能和 API 接口，方便开发...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值