1、【增加】RT-Thread 系统 Demo。

Signed-off-by: armink <armink.ztl@gmail.com>
2017-04-15 15:14:49 +08:00
parent cee09e4a57
commit b536a063d6
247 changed files with 137359 additions and 2 deletions
@@ -0,0 +1,707 @@
+/*
+ * File      : thread.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2006-03-28     Bernard      first version
+ * 2006-04-29     Bernard      implement thread timer
+ * 2006-04-30     Bernard      added THREAD_DEBUG
+ * 2006-05-27     Bernard      fixed the rt_thread_yield bug
+ * 2006-06-03     Bernard      fixed the thread timer init bug
+ * 2006-08-10     Bernard      fixed the timer bug in thread_sleep
+ * 2006-09-03     Bernard      changed rt_timer_delete to rt_timer_detach
+ * 2006-09-03     Bernard      implement rt_thread_detach
+ * 2008-02-16     Bernard      fixed the rt_thread_timeout bug
+ * 2010-03-21     Bernard      change the errno of rt_thread_delay/sleep to
+ *                             RT_EOK.
+ * 2010-11-10     Bernard      add cleanup callback function in thread exit.
+ * 2011-09-01     Bernard      fixed rt_thread_exit issue when the current
+ *                             thread preempted, which reported by Jiaxing Lee.
+ * 2011-09-08     Bernard      fixed the scheduling issue in rt_thread_startup.
+ * 2012-12-29     Bernard      fixed compiling warning.
+ */
+
+#include <rtthread.h>
+#include <rthw.h>
+
+extern rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX];
+extern struct rt_thread *rt_current_thread;
+extern rt_list_t rt_thread_defunct;
+
+static void rt_thread_exit(void)
+{
+    struct rt_thread *thread;
+    register rt_base_t level;
+
+    /* get current thread */
+    thread = rt_current_thread;
+
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
+
+    /* remove from schedule */
+    rt_schedule_remove_thread(thread);
+    /* change stat */
+    thread->stat = RT_THREAD_CLOSE;
+
+    /* remove it from timer list */
+    rt_timer_detach(&thread->thread_timer);
+
+    if ((rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE) &&
+        thread->cleanup == RT_NULL)
+    {
+        rt_object_detach((rt_object_t)thread);
+    }
+    else
+    {
+        /* insert to defunct thread list */
+        rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
+    }
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
+
+    /* switch to next task */
+    rt_schedule();
+}
+
+static rt_err_t _rt_thread_init(struct rt_thread *thread,
+                                const char       *name,
+                                void (*entry)(void *parameter),
+                                void             *parameter,
+                                void             *stack_start,
+                                rt_uint32_t       stack_size,
+                                rt_uint8_t        priority,
+                                rt_uint32_t       tick)
+{
+    /* init thread list */
+    rt_list_init(&(thread->tlist));
+
+    thread->entry = (void *)entry;
+    thread->parameter = parameter;
+
+    /* stack init */
+    thread->stack_addr = stack_start;
+    thread->stack_size = (rt_uint16_t)stack_size;
+
+    /* init thread stack */
+    rt_memset(thread->stack_addr, '#', thread->stack_size);
+    thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
+        (void *)((char *)thread->stack_addr + thread->stack_size - 4),
+        (void *)rt_thread_exit);
+
+    /* priority init */
+    RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
+    thread->init_priority    = priority;
+    thread->current_priority = priority;
+
+    /* tick init */
+    thread->init_tick      = tick;
+    thread->remaining_tick = tick;
+
+    /* error and flags */
+    thread->error = RT_EOK;
+    thread->stat  = RT_THREAD_INIT;
+
+    /* initialize cleanup function and user data */
+    thread->cleanup   = 0;
+    thread->user_data = 0;
+
+    /* init thread timer */
+    rt_timer_init(&(thread->thread_timer),
+                  thread->name,
+                  rt_thread_timeout,
+                  thread,
+                  0,
+                  RT_TIMER_FLAG_ONE_SHOT);
+
+    return RT_EOK;
+}
+
+/**
+ * @addtogroup Thread
+ */
+
+/*@{*/
+
+/**
+ * This function will initialize a thread, normally it's used to initialize a
+ * static thread object.
+ *
+ * @param thread the static thread object
+ * @param name the name of thread, which shall be unique
+ * @param entry the entry function of thread
+ * @param parameter the parameter of thread enter function
+ * @param stack_start the start address of thread stack
+ * @param stack_size the size of thread stack
+ * @param priority the priority of thread
+ * @param tick the time slice if there are same priority thread
+ *
+ * @return the operation status, RT_EOK on OK, -RT_ERROR on error
+ */
+rt_err_t rt_thread_init(struct rt_thread *thread,
+                        const char       *name,
+                        void (*entry)(void *parameter),
+                        void             *parameter,
+                        void             *stack_start,
+                        rt_uint32_t       stack_size,
+                        rt_uint8_t        priority,
+                        rt_uint32_t       tick)
+{
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(stack_start != RT_NULL);
+
+    /* init thread object */
+    rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);
+
+    return _rt_thread_init(thread,
+                           name,
+                           entry,
+                           parameter,
+                           stack_start,
+                           stack_size,
+                           priority,
+                           tick);
+}
+RTM_EXPORT(rt_thread_init);
+
+/**
+ * This function will return self thread object
+ *
+ * @return the self thread object
+ */
+rt_thread_t rt_thread_self(void)
+{
+    return rt_current_thread;
+}
+RTM_EXPORT(rt_thread_self);
+
+/**
+ * This function will start a thread and put it to system ready queue
+ *
+ * @param thread the thread to be started
+ *
+ * @return the operation status, RT_EOK on OK, -RT_ERROR on error
+ */
+rt_err_t rt_thread_startup(rt_thread_t thread)
+{
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(thread->stat == RT_THREAD_INIT);
+
+    /* set current priority to init priority */
+    thread->current_priority = thread->init_priority;
+
+    /* calculate priority attribute */
+#if RT_THREAD_PRIORITY_MAX > 32
+    thread->number      = thread->current_priority >> 3;            /* 5bit */
+    thread->number_mask = 1L << thread->number;
+    thread->high_mask   = 1L << (thread->current_priority & 0x07);  /* 3bit */
+#else
+    thread->number_mask = 1L << thread->current_priority;
+#endif
+
+    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("startup a thread:%s with priority:%d\n",
+                                   thread->name, thread->init_priority));
+    /* change thread stat */
+    thread->stat = RT_THREAD_SUSPEND;
+    /* then resume it */
+    rt_thread_resume(thread);
+    if (rt_thread_self() != RT_NULL)
+    {
+        /* do a scheduling */
+        rt_schedule();
+    }
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_startup);
+
+/**
+ * This function will detach a thread. The thread object will be removed from
+ * thread queue and detached/deleted from system object management.
+ *
+ * @param thread the thread to be deleted
+ *
+ * @return the operation status, RT_EOK on OK, -RT_ERROR on error
+ */
+rt_err_t rt_thread_detach(rt_thread_t thread)
+{
+    rt_base_t lock;
+
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+
+    /* remove from schedule */
+    rt_schedule_remove_thread(thread);
+
+    /* release thread timer */
+    rt_timer_detach(&(thread->thread_timer));
+
+    /* change stat */
+    thread->stat = RT_THREAD_CLOSE;
+
+    /* detach object */
+    rt_object_detach((rt_object_t)thread);
+
+    if (thread->cleanup != RT_NULL)
+    {
+        /* disable interrupt */
+        lock = rt_hw_interrupt_disable();
+
+        /* insert to defunct thread list */
+        rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
+
+        /* enable interrupt */
+        rt_hw_interrupt_enable(lock);
+    }
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_detach);
+
+
+#ifdef RT_USING_HEAP
+/**
+ * This function will create a thread object and allocate thread object memory
+ * and stack.
+ *
+ * @param name the name of thread, which shall be unique
+ * @param entry the entry function of thread
+ * @param parameter the parameter of thread enter function
+ * @param stack_size the size of thread stack
+ * @param priority the priority of thread
+ * @param tick the time slice if there are same priority thread
+ *
+ * @return the created thread object
+ */
+rt_thread_t rt_thread_create(const char *name,
+                             void (*entry)(void *parameter),
+                             void       *parameter,
+                             rt_uint32_t stack_size,
+                             rt_uint8_t  priority,
+                             rt_uint32_t tick)
+{
+    struct rt_thread *thread;
+    void *stack_start;
+
+    thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread,
+                                                    name);
+    if (thread == RT_NULL)
+        return RT_NULL;
+
+    stack_start = (void *)RT_KERNEL_MALLOC(stack_size);
+    if (stack_start == RT_NULL)
+    {
+        /* allocate stack failure */
+        rt_object_delete((rt_object_t)thread);
+
+        return RT_NULL;
+    }
+
+    _rt_thread_init(thread,
+                    name,
+                    entry,
+                    parameter,
+                    stack_start,
+                    stack_size,
+                    priority,
+                    tick);
+
+    return thread;
+}
+RTM_EXPORT(rt_thread_create);
+
+/**
+ * This function will delete a thread. The thread object will be removed from
+ * thread queue and detached/deleted from system object management.
+ *
+ * @param thread the thread to be deleted
+ *
+ * @return the operation status, RT_EOK on OK, -RT_ERROR on error
+ */
+rt_err_t rt_thread_delete(rt_thread_t thread)
+{
+    rt_base_t lock;
+
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+
+    /* remove from schedule */
+    rt_schedule_remove_thread(thread);
+
+    /* release thread timer */
+    rt_timer_detach(&(thread->thread_timer));
+
+    /* change stat */
+    thread->stat = RT_THREAD_CLOSE;
+
+    /* disable interrupt */
+    lock = rt_hw_interrupt_disable();
+
+    /* insert to defunct thread list */
+    rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(lock);
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_delete);
+#endif
+
+/**
+ * This function will let current thread yield processor, and scheduler will
+ * choose a highest thread to run. After yield processor, the current thread
+ * is still in READY state.
+ *
+ * @return RT_EOK
+ */
+rt_err_t rt_thread_yield(void)
+{
+    register rt_base_t level;
+    struct rt_thread *thread;
+
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
+
+    /* set to current thread */
+    thread = rt_current_thread;
+
+    /* if the thread stat is READY and on ready queue list */
+    if (thread->stat == RT_THREAD_READY &&
+        thread->tlist.next != thread->tlist.prev)
+    {
+        /* remove thread from thread list */
+        rt_list_remove(&(thread->tlist));
+
+        /* put thread to end of ready queue */
+        rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),
+                              &(thread->tlist));
+
+        /* enable interrupt */
+        rt_hw_interrupt_enable(level);
+
+        rt_schedule();
+
+        return RT_EOK;
+    }
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_yield);
+
+/**
+ * This function will let current thread sleep for some ticks.
+ *
+ * @param tick the sleep ticks
+ *
+ * @return RT_EOK
+ */
+rt_err_t rt_thread_sleep(rt_tick_t tick)
+{
+    register rt_base_t temp;
+    struct rt_thread *thread;
+
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
+    /* set to current thread */
+    thread = rt_current_thread;
+    RT_ASSERT(thread != RT_NULL);
+
+    /* suspend thread */
+    rt_thread_suspend(thread);
+
+    /* reset the timeout of thread timer and start it */
+    rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);
+    rt_timer_start(&(thread->thread_timer));
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
+
+    rt_schedule();
+
+    /* clear error number of this thread to RT_EOK */
+    if (thread->error == -RT_ETIMEOUT)
+        thread->error = RT_EOK;
+
+    return RT_EOK;
+}
+
+/**
+ * This function will let current thread delay for some ticks.
+ *
+ * @param tick the delay ticks
+ *
+ * @return RT_EOK
+ */
+rt_err_t rt_thread_delay(rt_tick_t tick)
+{
+    return rt_thread_sleep(tick);
+}
+RTM_EXPORT(rt_thread_delay);
+
+/**
+ * This function will control thread behaviors according to control command.
+ *
+ * @param thread the specified thread to be controlled
+ * @param cmd the control command, which includes
+ *  RT_THREAD_CTRL_CHANGE_PRIORITY for changing priority level of thread;
+ *  RT_THREAD_CTRL_STARTUP for starting a thread;
+ *  RT_THREAD_CTRL_CLOSE for delete a thread.
+ * @param arg the argument of control command
+ *
+ * @return RT_EOK
+ */
+rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void *arg)
+{
+    register rt_base_t temp;
+
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+
+    switch (cmd)
+    {
+    case RT_THREAD_CTRL_CHANGE_PRIORITY:
+        /* disable interrupt */
+        temp = rt_hw_interrupt_disable();
+
+        /* for ready thread, change queue */
+        if (thread->stat == RT_THREAD_READY)
+        {
+            /* remove thread from schedule queue first */
+            rt_schedule_remove_thread(thread);
+
+            /* change thread priority */
+            thread->current_priority = *(rt_uint8_t *)arg;
+
+            /* recalculate priority attribute */
+#if RT_THREAD_PRIORITY_MAX > 32
+            thread->number      = thread->current_priority >> 3;            /* 5bit */
+            thread->number_mask = 1 << thread->number;
+            thread->high_mask   = 1 << (thread->current_priority & 0x07);   /* 3bit */
+#else
+            thread->number_mask = 1 << thread->current_priority;
+#endif
+
+            /* insert thread to schedule queue again */
+            rt_schedule_insert_thread(thread);
+        }
+        else
+        {
+            thread->current_priority = *(rt_uint8_t *)arg;
+
+            /* recalculate priority attribute */
+#if RT_THREAD_PRIORITY_MAX > 32
+            thread->number      = thread->current_priority >> 3;            /* 5bit */
+            thread->number_mask = 1 << thread->number;
+            thread->high_mask   = 1 << (thread->current_priority & 0x07);   /* 3bit */
+#else
+            thread->number_mask = 1 << thread->current_priority;
+#endif
+        }
+
+        /* enable interrupt */
+        rt_hw_interrupt_enable(temp);
+        break;
+
+    case RT_THREAD_CTRL_STARTUP:
+        return rt_thread_startup(thread);
+
+#ifdef RT_USING_HEAP
+    case RT_THREAD_CTRL_CLOSE:
+        return rt_thread_delete(thread);
+#endif
+
+    default:
+        break;
+    }
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_control);
+
+/**
+ * This function will suspend the specified thread.
+ *
+ * @param thread the thread to be suspended
+ *
+ * @return the operation status, RT_EOK on OK, -RT_ERROR on error
+ *
+ * @note if suspend self thread, after this function call, the
+ * rt_schedule() must be invoked.
+ */
+rt_err_t rt_thread_suspend(rt_thread_t thread)
+{
+    register rt_base_t temp;
+
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+
+    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend:  %s\n", thread->name));
+
+    if (thread->stat != RT_THREAD_READY)
+    {
+        RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend: thread disorder, %d\n",
+                                       thread->stat));
+
+        return -RT_ERROR;
+    }
+
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
+
+    /* change thread stat */
+    thread->stat = RT_THREAD_SUSPEND;
+    rt_schedule_remove_thread(thread);
+
+    /* stop thread timer anyway */
+    rt_timer_stop(&(thread->thread_timer));
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_suspend);
+
+/**
+ * This function will resume a thread and put it to system ready queue.
+ *
+ * @param thread the thread to be resumed
+ *
+ * @return the operation status, RT_EOK on OK, -RT_ERROR on error
+ */
+rt_err_t rt_thread_resume(rt_thread_t thread)
+{
+    register rt_base_t temp;
+
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+
+    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume:  %s\n", thread->name));
+
+    if (thread->stat != RT_THREAD_SUSPEND)
+    {
+        RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: thread disorder, %d\n",
+                                       thread->stat));
+
+        return -RT_ERROR;
+    }
+
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
+
+    /* remove from suspend list */
+    rt_list_remove(&(thread->tlist));
+
+    rt_timer_stop(&thread->thread_timer);
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
+
+    /* insert to schedule ready list */
+    rt_schedule_insert_thread(thread);
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_resume);
+
+/**
+ * This function is the timeout function for thread, normally which is invoked
+ * when thread is timeout to wait some resource.
+ *
+ * @param parameter the parameter of thread timeout function
+ */
+void rt_thread_timeout(void *parameter)
+{
+    struct rt_thread *thread;
+
+    thread = (struct rt_thread *)parameter;
+
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(thread->stat == RT_THREAD_SUSPEND);
+
+    /* set error number */
+    thread->error = -RT_ETIMEOUT;
+
+    /* remove from suspend list */
+    rt_list_remove(&(thread->tlist));
+
+    /* insert to schedule ready list */
+    rt_schedule_insert_thread(thread);
+
+    /* do schedule */
+    rt_schedule();
+}
+RTM_EXPORT(rt_thread_timeout);
+
+/**
+ * This function will find the specified thread.
+ *
+ * @param name the name of thread finding
+ *
+ * @return the found thread
+ *
+ * @note please don't invoke this function in interrupt status.
+ */
+rt_thread_t rt_thread_find(char *name)
+{
+    struct rt_object_information *information;
+    struct rt_object *object;
+    struct rt_list_node *node;
+
+    extern struct rt_object_information rt_object_container[];
+
+    /* enter critical */
+    if (rt_thread_self() != RT_NULL)
+        rt_enter_critical();
+
+    /* try to find device object */
+    information = &rt_object_container[RT_Object_Class_Thread];
+    for (node  = information->object_list.next;
+         node != &(information->object_list);
+         node  = node->next)
+    {
+        object = rt_list_entry(node, struct rt_object, list);
+        if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)
+        {
+            /* leave critical */
+            if (rt_thread_self() != RT_NULL)
+                rt_exit_critical();
+
+            return (rt_thread_t)object;
+        }
+    }
+
+    /* leave critical */
+    if (rt_thread_self() != RT_NULL)
+        rt_exit_critical();
+
+    /* not found */
+    return RT_NULL;
+}
+RTM_EXPORT(rt_thread_find);
+
+/*@}*/