rtthread：消息队列

1 消息队列

  消息队列是一种常用的线程间异步通讯方式； 

  消息队列能够接收来自线程或中断中不固定长度的消息，并把消息缓存在自己的内存空间中，供线程间进行异步通讯；

  1.1 结构体定义

//rtconfig.h    源码默认注释掉未开启，用到消息队列的时候需要自己开启；
#define RT_USING_MESSAGEQUEUE
 
//rtdef.h 
#ifdef RT_USING_MESSAGEQUEUE
struct rt_messagequeue
{
    struct rt_ipc_object parent;                        /**< inherit from ipc_object */
 
    void                *msg_pool;                      /**< start address of message queue */
 
    rt_uint16_t          msg_size;                      /**< message size of each message */
    rt_uint16_t          max_msgs;                      /**< max number of messages */
 
    rt_uint16_t          entry;                         /**< index of messages in the queue */
 
    void                *msg_queue_head;                /**< list head */
    void                *msg_queue_tail;                /**< list tail */
    void                *msg_queue_free;                /**< pointer indicated the free node of queue */
};
typedef struct rt_messagequeue *rt_mq_t;
#endif
 
 
//rtdef.h     suspend_thread在create函数中初始化，作为suspend线程的链表节点来挂载;
struct rt_ipc_object
{
    struct rt_object parent;                            /**< inherit from rt_object */
    rt_list_t        suspend_thread;                    /**< threads pended on this resource */
};
 
 
//ipc.c       和rt_mq_init()函数一起定义的; 
//rt_mq_init()静态创建mq结构体，rt_mq_create()动态创建mq结构体;demo里用的动态创建的;
#ifdef RT_USING_MESSAGEQUEUE
struct rt_mq_message
{
    struct rt_mq_message *next;
};

  1.2 rt_mq_create 消息队列初始化

    

    分配rt_messagequeue结构体内存，初始化以及分配空闲链表消息池；

//ipc.c
rt_mq_t rt_mq_create(const char *name,
                     rt_size_t   msg_size,
                     rt_size_t   max_msgs,
                     rt_uint8_t  flag)
{
    struct rt_messagequeue *mq;
    struct rt_mq_message *head;
    register rt_base_t temp;
 
    RT_DEBUG_NOT_IN_INTERRUPT;
 
    /* allocate object */
    mq = (rt_mq_t)rt_object_allocate(RT_Object_Class_MessageQueue, name);
    if (mq == RT_NULL)
        return mq;
 
    /* set parent */
    mq->parent.parent.flag = flag;
 
    /* init ipc object */
    rt_ipc_object_init(&(mq->parent));
 
    /* init message queue */
 
    /* get correct message size */
    mq->msg_size = RT_ALIGN(msg_size, RT_ALIGN_SIZE);
    mq->max_msgs = max_msgs;
 
    /* allocate message pool (消息size + messagenext链表)*消息个数   */
    mq->msg_pool = RT_KERNEL_MALLOC((mq->msg_size + sizeof(struct rt_mq_message)) * mq->max_msgs);
    if (mq->msg_pool == RT_NULL)
    {
        rt_mq_delete(mq);
 
        return RT_NULL;
    }
 
    /* init message list */
    mq->msg_queue_head = RT_NULL;
    mq->msg_queue_tail = RT_NULL;
 
    /* init message empty list */
    mq->msg_queue_free = RT_NULL;
    for (temp = 0; temp < mq->max_msgs; temp ++)
    {
        head = (struct rt_mq_message *)((rt_uint8_t *)mq->msg_pool +
                                        temp * (mq->msg_size + sizeof(struct rt_mq_message)));
        head->next = mq->msg_queue_free;
        mq->msg_queue_free = head;
    }
 
    /* the initial entry is zero */
    mq->entry = 0;
 
    return mq;
}
RTM_EXPORT(rt_mq_create);

  1.3 rt_mq_send 消息队列发送

    从空闲msg_pool中取出msg_queue_free链表，然后插入到消息msg_pool中等待发送；

    如果mq->parent.suspend_thread不为空，则把suspend_thread从suspend_list中删除之后然后再挂载回优先级表中启动调度；

//ipc.c
rt_err_t rt_mq_send(rt_mq_t mq, void *buffer, rt_size_t size)
{
    register rt_ubase_t temp;
    struct rt_mq_message *msg;
 
    RT_ASSERT(mq != RT_NULL);
    RT_ASSERT(buffer != RT_NULL);
    RT_ASSERT(size != 0);
 
    /* greater than one message size */
    if (size > mq->msg_size)
        return -RT_ERROR;
 
    RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent)));
 
    /* disable interrupt */
    temp = rt_hw_interrupt_disable();
 
    /* get a free list, there must be an empty item */
    msg = (struct rt_mq_message *)mq->msg_queue_free;                  //msg: &head2;
    /* message queue is full */
    if (msg == RT_NULL)
    {
        /* enable interrupt */
        rt_hw_interrupt_enable(temp);
 
        return -RT_EFULL;
    }
    /* move free list pointer */
    mq->msg_queue_free = msg->next;                                    //msg_queue_free: &head1;
 
    /* enable interrupt */
    rt_hw_interrupt_enable(temp);
 
    /* the msg is the new tailer of list, the next shall be NULL */
    msg->next = RT_NULL;              //msg->next:null,不知道为什么要清空，因为作为一个新的消息等会用来插入msg_pool中;
    /* copy buffer */
    rt_memcpy(msg + 1, buffer, size); //将消息存入msg_size大小的空间中,不知道为什么要加1，这里已经是新消息的地址啦;
 
    /* disable interrupt */
    temp = rt_hw_interrupt_disable();
    /* link msg to message queue */
    if (mq->msg_queue_tail != RT_NULL)
    {
        /* if the tail exists, */
        ((struct rt_mq_message *)mq->msg_queue_tail)->next = msg;
    }
 
    /* set new tail */
    mq->msg_queue_tail = msg;
    /* if the head is empty, set head */
    if (mq->msg_queue_head == RT_NULL)
        mq->msg_queue_head = msg;
 
    /* increase message entry */
    mq->entry ++;
 
    /* resume suspended thread */
    if (!rt_list_isempty(&mq->parent.suspend_thread))
    {
        rt_ipc_list_resume(&(mq->parent.suspend_thread));
 
        /* enable interrupt */
        rt_hw_interrupt_enable(temp);
 
        rt_schedule();
 
        return RT_EOK;
    }
 
    /* enable interrupt */
    rt_hw_interrupt_enable(temp);
 
    return RT_EOK;
}
RTM_EXPORT(rt_mq_send);

  1.4 rt_mq_recv消息队列接收

    从消息队列中取出数据，然后把取出数据的消息地址放回空闲池里；

//ipc.c
rt_err_t rt_mq_recv(rt_mq_t    mq,
                    void      *buffer,
                    rt_size_t  size,
                    rt_int32_t timeout)
{
    struct rt_thread *thread;
    register rt_ubase_t temp;
    struct rt_mq_message *msg;
    rt_uint32_t tick_delta;
 
    RT_ASSERT(mq != RT_NULL);
    RT_ASSERT(buffer != RT_NULL);
    RT_ASSERT(size != 0);
 
    /* initialize delta tick */
    tick_delta = 0;
    /* get current thread */
    thread = rt_thread_self();
    RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mq->parent.parent)));
 
    /* disable interrupt */
    temp = rt_hw_interrupt_disable();
 
    /* for non-blocking call 如果消息队列中没有消息且不等待消息，就直接返回;*/
    if (mq->entry == 0 && timeout == 0)
    {
        rt_hw_interrupt_enable(temp);
 
        return -RT_ETIMEOUT;
    }
 
    /* message queue is empty 如果消息队列中没有消息，通过timeout判断是否等待处理;*/
    while (mq->entry == 0)
    {
        RT_DEBUG_IN_THREAD_CONTEXT;
 
        /* reset error number in thread */
        thread->error = RT_EOK;
 
        /* no waiting, return timeout */
        if (timeout == 0)
        {
            /* enable interrupt */
            rt_hw_interrupt_enable(temp);
 
            thread->error = -RT_ETIMEOUT;
 
            return -RT_ETIMEOUT;
        }
 
        /* suspend current thread */
        rt_ipc_list_suspend(&(mq->parent.suspend_thread),
                            thread,
                            mq->parent.parent.flag);
 
        /* has waiting time, start thread timer */
        if (timeout > 0)
        {
            /* get the start tick of timer */
            tick_delta = rt_tick_get();
 
            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,
                             &timeout);
            rt_timer_start(&(thread->thread_timer));
        }
 
        /* enable interrupt */
        rt_hw_interrupt_enable(temp);
 
        /* re-schedule */
        rt_schedule();
 
        /* recv message */
        if (thread->error != RT_EOK)
        {
            /* return error */
            return thread->error;
        }
 
        /* disable interrupt */
        temp = rt_hw_interrupt_disable();
 
        /* if it's not waiting forever and then re-calculate timeout tick */
        if (timeout > 0)
        {
            tick_delta = rt_tick_get() - tick_delta;
            timeout -= tick_delta;
            if (timeout < 0)
                timeout = 0;
        }
    }
 
    /* get message from queue **********先放着，**************************/
    msg = (struct rt_mq_message *)mq->msg_queue_head;
 
    /* move message queue head */
    mq->msg_queue_head = msg->next;
    /* reach queue tail, set to NULL */
    if (mq->msg_queue_tail == msg)
        mq->msg_queue_tail = RT_NULL;
 
    /* decrease message entry */
    mq->entry --;
 
    /* enable interrupt */
    rt_hw_interrupt_enable(temp);
 
    /* copy message  发送函数中msg地址加1不理解，不过这里也+1回去了,只是觉得没必要;*/
    rt_memcpy(buffer, msg + 1, size > mq->msg_size ? mq->msg_size : size);
 
    /* disable interrupt */
    temp = rt_hw_interrupt_disable();
    /* put message to free list 将用完的消息地址放回空闲池;存放方式类似堆栈push和pop; */
    msg->next = (struct rt_mq_message *)mq->msg_queue_free;
    mq->msg_queue_free = msg;
    /* enable interrupt */
    rt_hw_interrupt_enable(temp);
 
    RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mq->parent.parent)));
 
    return RT_EOK;
}
RTM_EXPORT(rt_mq_recv);

  1.5 收发消息队列图

    

    不知道为什么用memcpy( )的时候收发的msg 地址都加1了，我觉得那里分配的地址应该不需要加1的，可是不加1会报错，先放着吧，以后再说；

  1.6 suspend_thread链表节点

//在rt_mq_send函数中，发送数据的时候，储存完数据之后会把suspend_thread恢复；
//这个函数的目的是要是先执行了接收函数，而消息队列中又没有消息，接收函数就被挂起了，这里接收到消息了，所以恢复函数;
    /* resume suspended thread */
    if (!rt_list_isempty(&mq->parent.suspend_thread))
    {
        rt_ipc_list_resume(&(mq->parent.suspend_thread));
 
        /* enable interrupt */
        rt_hw_interrupt_enable(temp);
 
        rt_schedule();
 
        return RT_EOK;
    }
 
//在rt_mq_recv函数中，消息池中需要先存储了数据才可以接收数据;要是没有存储数据就先把线程挂起，直到while(!entry);
    while (mq->entry == 0)
    {
        /* suspend current thread */
        rt_ipc_list_suspend(&(mq->parent.suspend_thread),
                            thread,
                            mq->parent.parent.flag);
        //要是定了超时时间，那么就开启定时器，时间到了就回来看看是否退出while循坏;
    }
 
//这个信息是如何在两个线程间传递的，我有一点不理解，先放着吧；
//消息队列就相当于静态内存，然后存取数据的时候传递的是地址来存取数据;

2 小结

  每次分配地址和数据的时候分界点的边界总是有点迷糊，都得重新找一遍规律，这样不行呀；

  指针向下移动第几个，就是移动到第几位地址；[0]+5 = [5]，[2]+5 = [7]；msg_pool的地址从head头移动到head尾，要+1才到下面消息地址；

  接收里有好几个if(timeout>0),也不知道都有啥用；开启定时器，定时器到期之后再回来执行，看看是不是要退出while循坏；

  parent.suspend_thread的处理流程是怎么样的呢？