nrf51822程序的分析( 三）

nrf51822程序的分析( 三）

接着上篇分析，这次写一下NRF51822提供的调度机制。

---

1.6.NRF51822调度机制

1.6.1.调度原理

首先用一组循环队列来放置事件，分别是存放事件数据，事件回调函数和事件数据大小。
事件队列中存放的基本单元的数据结构如下：

//这个是存放回调指针和数据长度的队列结构体的队列指针
static event_header_t * m_queue_event_headers;     
typedef void (*app_sched_event_handler_t)(void * p_event_data, uint16_t event_size);
typedef struct 
{
    app_sched_event_handler_t handler;    /**< 在事件处理程序中的指针用来接收事件 */
    uint16_t                  event_data_size;     /**< 事件的数据长度 */
} event_header_t;

//这个是用来存储事件自带的数据的数组
static uint8_t *        m_queue_event_data;     

当其他应用需要给另一个应用发送数据时就将事件put到事件循环队列中，而回调函数的指定都是有用户自身的逻辑需要进行指定的。
然后在主循环中对事件队列中的数据按照顺序，进行读取和回调函数的调用。

1.6.2.调度初始化

初始化中分配了APP_SCHED_BUF变量的缓冲区，作为事件队列，并设置了事件队列的长度和最大事件长度。事件的最大长度是app_timer_event_t类型的大小。

#define SCHED_MAX_EVENT_DATA_SIZE       sizeof(app_timer_event_t)                   /**< 事件调度最大长度。 注意，当事件在事件处理程序中从堆栈中提取时，调度程序堆栈事件不包含任何数据。 */

typedef struct
{
    app_timer_timeout_handler_t timeout_handler;    //超时回调函数的函数指针
    void *                      p_context;
} app_timer_event_t;

---

static void scheduler_init(void)
{
    APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE);
}

#define APP_SCHED_INIT(EVENT_SIZE, QUEUE_SIZE)                              \
    do                                                                  \
    {                                                                      \
        static uint32_t APP_SCHED_BUF[CEIL_DIV(APP_SCHED_BUF_SIZE((EVENT_SIZE), (QUEUE_SIZE)),     \
                                       sizeof(uint32_t))];             \
        uint32_t ERR_CODE = app_sched_init((EVENT_SIZE), (QUEUE_SIZE), APP_SCHED_BUF);    \
        APP_ERROR_CHECK(ERR_CODE);                                     \
    } while (0)


uint32_t app_sched_init(uint16_t event_size, uint16_t queue_size, void * p_event_buffer)
{
    uint16_t data_start_index = (queue_size + 1) * sizeof(event_header_t);
    if (!is_word_aligned(p_event_buffer))  // 检测内存是否对齐
    {
        return NRF_ERROR_INVALID_PARAM;
    }

    // 初始化调度
    m_queue_event_headers = p_event_buffer;
    m_queue_event_data    = &((uint8_t *)p_event_buffer)[data_start_index];
    m_queue_end_index     = 0;
    m_queue_start_index   = 0;
    m_queue_event_size    = event_size;
    m_queue_size          = queue_size;

    return NRF_SUCCESS;
}

1.6.3.向内核发送事件

向内核发送事件的代码如下：中间对队列的操作，考虑到可能不同的应用同时调用，否则会导致线程安全问题，因此这里需要进入/退出临界区的宏操作进行保护。

uint32_t app_sched_event_put(void *                    p_event_data,
                             uint16_t                  event_data_size,
                             app_sched_event_handler_t handler)
{
    uint32_t err_code;

    if (event_data_size <= m_queue_event_size)
    {
        uint16_t event_index = 0xFFFF;
        CRITICAL_REGION_ENTER();          
        if (!APP_SCHED_QUEUE_FULL())      //判断队列是否满
        {
            event_index       = m_queue_end_index;
            m_queue_end_index = next_index(m_queue_end_index);
        }

        CRITICAL_REGION_EXIT();
        if (event_index != 0xFFFF)
        {
           //注意：这可以在关键区域之外进行，因为事件使用者总是从主循环调用，因此不会中断此代码。
            m_queue_event_headers[event_index].handler = handler;   //放入句柄
            if ((p_event_data != NULL) && (event_data_size > 0))
            {    
                memcpy(&m_queue_event_data[event_index * m_queue_event_size],
                       p_event_data,
                       event_data_size);      //放入数据
                m_queue_event_headers[event_index].event_data_size = event_data_size;      //存放长度
            }
            else
            {
                m_queue_event_headers[event_index].event_data_size = 0;
            }
            err_code = NRF_SUCCESS;
        }
        else
        {     //事件满不做处理，返回错误值
            err_code = NRF_ERROR_NO_MEM;
        }
    }
    else
    {
        err_code = NRF_ERROR_INVALID_LENGTH;
    }

    return err_code;
}

1.6.4.事件调度内核

调度的内核在主循环中的app_sched_execute函数。调度内核的原理就是从事件队列中每次取出一组队列中的事件信息，事件回调句柄，并进行事件回调函数的调用（同时传入事件信息）。while循环，直到队列中的数据都被清空。

void app_sched_execute(void)
{
    void *                    p_event_data;
    uint16_t                  event_data_size;
    app_sched_event_handler_t event_handler;
    // 得到下一个事件并执行
    while ((app_sched_event_get(&p_event_data, &event_data_size, &event_handler) == NRF_SUCCESS))
    {
        event_handler(p_event_data, event_data_size);
    }
}


static uint32_t app_sched_event_get(void **                     pp_event_data,
                                    uint16_t *                  p_event_data_size,
                                    app_sched_event_handler_t * p_event_handler)
{
    uint32_t err_code = NRF_ERROR_NOT_FOUND;

    if (!APP_SCHED_QUEUE_EMPTY())     //判断调度队列是否为空
    {
        uint16_t event_index;
        // 注：有没有必要为一个临界区这里，这个函数只会被app_sched_execute()内部主循环。
        // 因此他永远不会中断app_sched_event_put()。此外，更新（即写入）开始索引将是一个原子操作
        event_index         = m_queue_start_index;
        m_queue_start_index = next_index(m_queue_start_index);

        *pp_event_data     = &m_queue_event_data[event_index * m_queue_event_size];
        *p_event_data_size = m_queue_event_headers[event_index].event_data_size;
        *p_event_handler   = m_queue_event_headers[event_index].handler;

        err_code = NRF_SUCCESS;
    }
    return err_code;
}