Rob Kluin / nRF51822

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of nRF51822 by Nordic Semiconductor

nordic-sdk/components/libraries/scheduler/app_scheduler.c@345:dfde56236c36, 2015-06-19 (annotated)

Committer:
rgrover1
Date:
Fri Jun 19 15:55:35 2015 +0100
Revision:
345:dfde56236c36
Parent:
343:6675661fa600
Child:
346:14b090482fd2
Synchronized with git rev fbfc6d16

Author: Andrew Fernandes

Fix various GCC compilation issues.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
rgrover1 345:dfde56236c36 1 /* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved.
rgrover1 345:dfde56236c36 2 *
rgrover1 345:dfde56236c36 3 * The information contained herein is property of Nordic Semiconductor ASA.
rgrover1 345:dfde56236c36 4 * Terms and conditions of usage are described in detail in NORDIC
rgrover1 345:dfde56236c36 5 * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
rgrover1 345:dfde56236c36 6 *
rgrover1 345:dfde56236c36 7 * Licensees are granted free, non-transferable use of the information. NO
rgrover1 345:dfde56236c36 8 * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
rgrover1 345:dfde56236c36 9 * the file.
rgrover1 345:dfde56236c36 10 *
rgrover1 345:dfde56236c36 11 */
rgrover1 345:dfde56236c36 12
rgrover1 345:dfde56236c36 13 #include "app_scheduler.h"
rgrover1 345:dfde56236c36 14 #include <stdlib.h>
rgrover1 345:dfde56236c36 15 #include <stdint.h>
rgrover1 345:dfde56236c36 16 #include <string.h>
rgrover1 345:dfde56236c36 17 #include "nrf_soc.h"
rgrover1 345:dfde56236c36 18 #include "nrf_assert.h"
rgrover1 345:dfde56236c36 19 #include "app_util.h"
rgrover1 345:dfde56236c36 20 #include "app_util_platform.h"
rgrover1 345:dfde56236c36 21
rgrover1 345:dfde56236c36 22 /**@brief Structure for holding a scheduled event header. */
rgrover1 345:dfde56236c36 23 typedef struct
rgrover1 345:dfde56236c36 24 {
rgrover1 345:dfde56236c36 25 app_sched_event_handler_t handler; /**< Pointer to event handler to receive the event. */
rgrover1 345:dfde56236c36 26 uint16_t event_data_size; /**< Size of event data. */
rgrover1 345:dfde56236c36 27 } event_header_t;
rgrover1 345:dfde56236c36 28
rgrover1 345:dfde56236c36 29 STATIC_ASSERT(sizeof(event_header_t) <= APP_SCHED_EVENT_HEADER_SIZE);
rgrover1 345:dfde56236c36 30
rgrover1 345:dfde56236c36 31 static event_header_t * m_queue_event_headers; /**< Array for holding the queue event headers. */
rgrover1 345:dfde56236c36 32 static uint8_t * m_queue_event_data; /**< Array for holding the queue event data. */
rgrover1 345:dfde56236c36 33 static volatile uint8_t m_queue_start_index; /**< Index of queue entry at the start of the queue. */
rgrover1 345:dfde56236c36 34 static volatile uint8_t m_queue_end_index; /**< Index of queue entry at the end of the queue. */
rgrover1 345:dfde56236c36 35 static uint16_t m_queue_event_size; /**< Maximum event size in queue. */
rgrover1 345:dfde56236c36 36 static uint16_t m_queue_size; /**< Number of queue entries. */
rgrover1 345:dfde56236c36 37
rgrover1 345:dfde56236c36 38 /**@brief Function for incrementing a queue index, and handle wrap-around.
rgrover1 345:dfde56236c36 39 *
rgrover1 345:dfde56236c36 40 * @param[in] index Old index.
rgrover1 345:dfde56236c36 41 *
rgrover1 345:dfde56236c36 42 * @return New (incremented) index.
rgrover1 345:dfde56236c36 43 */
rgrover1 345:dfde56236c36 44 static __INLINE uint8_t next_index(uint8_t index)
rgrover1 345:dfde56236c36 45 {
rgrover1 345:dfde56236c36 46 return (index < m_queue_size) ? (index + 1) : 0;
rgrover1 345:dfde56236c36 47 }
rgrover1 345:dfde56236c36 48
rgrover1 345:dfde56236c36 49
rgrover1 345:dfde56236c36 50 static __INLINE uint8_t app_sched_queue_full()
rgrover1 345:dfde56236c36 51 {
rgrover1 345:dfde56236c36 52 uint8_t tmp = m_queue_start_index;
rgrover1 345:dfde56236c36 53 return next_index(m_queue_end_index) == tmp;
rgrover1 345:dfde56236c36 54 }
rgrover1 345:dfde56236c36 55
rgrover1 345:dfde56236c36 56 /**@brief Macro for checking if a queue is full. */
rgrover1 345:dfde56236c36 57 #define APP_SCHED_QUEUE_FULL() app_sched_queue_full()
rgrover1 345:dfde56236c36 58
rgrover1 345:dfde56236c36 59
rgrover1 345:dfde56236c36 60 static __INLINE uint8_t app_sched_queue_empty()
rgrover1 345:dfde56236c36 61 {
rgrover1 345:dfde56236c36 62 uint8_t tmp = m_queue_start_index;
rgrover1 345:dfde56236c36 63 return m_queue_end_index == tmp;
rgrover1 345:dfde56236c36 64 }
rgrover1 345:dfde56236c36 65
rgrover1 345:dfde56236c36 66 /**@brief Macro for checking if a queue is empty. */
rgrover1 345:dfde56236c36 67 #define APP_SCHED_QUEUE_EMPTY() app_sched_queue_empty()
rgrover1 345:dfde56236c36 68
rgrover1 345:dfde56236c36 69
rgrover1 345:dfde56236c36 70 uint32_t app_sched_init(uint16_t event_size, uint16_t queue_size, void * p_event_buffer)
rgrover1 345:dfde56236c36 71 {
rgrover1 345:dfde56236c36 72 uint16_t data_start_index = (queue_size + 1) * sizeof(event_header_t);
rgrover1 345:dfde56236c36 73
rgrover1 345:dfde56236c36 74 // Check that buffer is correctly aligned
rgrover1 345:dfde56236c36 75 if (!is_word_aligned(p_event_buffer))
rgrover1 345:dfde56236c36 76 {
rgrover1 345:dfde56236c36 77 return NRF_ERROR_INVALID_PARAM;
rgrover1 345:dfde56236c36 78 }
rgrover1 345:dfde56236c36 79
rgrover1 345:dfde56236c36 80 // Initialize event scheduler
rgrover1 345:dfde56236c36 81 m_queue_event_headers = p_event_buffer;
rgrover1 345:dfde56236c36 82 m_queue_event_data = &((uint8_t *)p_event_buffer)[data_start_index];
rgrover1 345:dfde56236c36 83 m_queue_end_index = 0;
rgrover1 345:dfde56236c36 84 m_queue_start_index = 0;
rgrover1 345:dfde56236c36 85 m_queue_event_size = event_size;
rgrover1 345:dfde56236c36 86 m_queue_size = queue_size;
rgrover1 345:dfde56236c36 87
rgrover1 345:dfde56236c36 88 return NRF_SUCCESS;
rgrover1 345:dfde56236c36 89 }
rgrover1 345:dfde56236c36 90
rgrover1 345:dfde56236c36 91
rgrover1 345:dfde56236c36 92 uint32_t app_sched_event_put(void * p_event_data,
rgrover1 345:dfde56236c36 93 uint16_t event_data_size,
rgrover1 345:dfde56236c36 94 app_sched_event_handler_t handler)
rgrover1 345:dfde56236c36 95 {
rgrover1 345:dfde56236c36 96 uint32_t err_code;
rgrover1 345:dfde56236c36 97
rgrover1 345:dfde56236c36 98 if (event_data_size <= m_queue_event_size)
rgrover1 345:dfde56236c36 99 {
rgrover1 345:dfde56236c36 100 uint16_t event_index = 0xFFFF;
rgrover1 345:dfde56236c36 101
rgrover1 345:dfde56236c36 102 CRITICAL_REGION_ENTER();
rgrover1 345:dfde56236c36 103
rgrover1 345:dfde56236c36 104 if (!APP_SCHED_QUEUE_FULL())
rgrover1 345:dfde56236c36 105 {
rgrover1 345:dfde56236c36 106 event_index = m_queue_end_index;
rgrover1 345:dfde56236c36 107 m_queue_end_index = next_index(m_queue_end_index);
rgrover1 345:dfde56236c36 108 }
rgrover1 345:dfde56236c36 109
rgrover1 345:dfde56236c36 110 CRITICAL_REGION_EXIT();
rgrover1 345:dfde56236c36 111
rgrover1 345:dfde56236c36 112 if (event_index != 0xFFFF)
rgrover1 345:dfde56236c36 113 {
rgrover1 345:dfde56236c36 114 // NOTE: This can be done outside the critical region since the event consumer will
rgrover1 345:dfde56236c36 115 // always be called from the main loop, and will thus never interrupt this code.
rgrover1 345:dfde56236c36 116 m_queue_event_headers[event_index].handler = handler;
rgrover1 345:dfde56236c36 117 if ((p_event_data != NULL) && (event_data_size > 0))
rgrover1 345:dfde56236c36 118 {
rgrover1 345:dfde56236c36 119 memcpy(&m_queue_event_data[event_index * m_queue_event_size],
rgrover1 345:dfde56236c36 120 p_event_data,
rgrover1 345:dfde56236c36 121 event_data_size);
rgrover1 345:dfde56236c36 122 m_queue_event_headers[event_index].event_data_size = event_data_size;
rgrover1 345:dfde56236c36 123 }
rgrover1 345:dfde56236c36 124 else
rgrover1 345:dfde56236c36 125 {
rgrover1 345:dfde56236c36 126 m_queue_event_headers[event_index].event_data_size = 0;
rgrover1 345:dfde56236c36 127 }
rgrover1 345:dfde56236c36 128
rgrover1 345:dfde56236c36 129 err_code = NRF_SUCCESS;
rgrover1 345:dfde56236c36 130 }
rgrover1 345:dfde56236c36 131 else
rgrover1 345:dfde56236c36 132 {
rgrover1 345:dfde56236c36 133 err_code = NRF_ERROR_NO_MEM;
rgrover1 345:dfde56236c36 134 }
rgrover1 345:dfde56236c36 135 }
rgrover1 345:dfde56236c36 136 else
rgrover1 345:dfde56236c36 137 {
rgrover1 345:dfde56236c36 138 err_code = NRF_ERROR_INVALID_LENGTH;
rgrover1 345:dfde56236c36 139 }
rgrover1 345:dfde56236c36 140
rgrover1 345:dfde56236c36 141 return err_code;
rgrover1 345:dfde56236c36 142 }
rgrover1 345:dfde56236c36 143
rgrover1 345:dfde56236c36 144
rgrover1 345:dfde56236c36 145 /**@brief Function for reading the next event from specified event queue.
rgrover1 345:dfde56236c36 146 *
rgrover1 345:dfde56236c36 147 * @param[out] pp_event_data Pointer to pointer to event data.
rgrover1 345:dfde56236c36 148 * @param[out] p_event_data_size Pointer to size of event data.
rgrover1 345:dfde56236c36 149 * @param[out] p_event_handler Pointer to event handler function pointer.
rgrover1 345:dfde56236c36 150 *
rgrover1 345:dfde56236c36 151 * @return NRF_SUCCESS if new event, NRF_ERROR_NOT_FOUND if event queue is empty.
rgrover1 345:dfde56236c36 152 */
rgrover1 345:dfde56236c36 153 static uint32_t app_sched_event_get(void ** pp_event_data,
rgrover1 345:dfde56236c36 154 uint16_t * p_event_data_size,
rgrover1 345:dfde56236c36 155 app_sched_event_handler_t * p_event_handler)
rgrover1 345:dfde56236c36 156 {
rgrover1 345:dfde56236c36 157 uint32_t err_code = NRF_ERROR_NOT_FOUND;
rgrover1 345:dfde56236c36 158
rgrover1 345:dfde56236c36 159 if (!APP_SCHED_QUEUE_EMPTY())
rgrover1 345:dfde56236c36 160 {
rgrover1 345:dfde56236c36 161 uint16_t event_index;
rgrover1 345:dfde56236c36 162
rgrover1 345:dfde56236c36 163 // NOTE: There is no need for a critical region here, as this function will only be called
rgrover1 345:dfde56236c36 164 // from app_sched_execute() from inside the main loop, so it will never interrupt
rgrover1 345:dfde56236c36 165 // app_sched_event_put(). Also, updating of (i.e. writing to) the start index will be
rgrover1 345:dfde56236c36 166 // an atomic operation.
rgrover1 345:dfde56236c36 167 event_index = m_queue_start_index;
rgrover1 345:dfde56236c36 168 m_queue_start_index = next_index(m_queue_start_index);
rgrover1 345:dfde56236c36 169
rgrover1 345:dfde56236c36 170 *pp_event_data = &m_queue_event_data[event_index * m_queue_event_size];
rgrover1 345:dfde56236c36 171 *p_event_data_size = m_queue_event_headers[event_index].event_data_size;
rgrover1 345:dfde56236c36 172 *p_event_handler = m_queue_event_headers[event_index].handler;
rgrover1 345:dfde56236c36 173
rgrover1 345:dfde56236c36 174 err_code = NRF_SUCCESS;
rgrover1 345:dfde56236c36 175 }
rgrover1 345:dfde56236c36 176
rgrover1 345:dfde56236c36 177 return err_code;
rgrover1 345:dfde56236c36 178 }
rgrover1 345:dfde56236c36 179
rgrover1 345:dfde56236c36 180
rgrover1 345:dfde56236c36 181 void app_sched_execute(void)
rgrover1 345:dfde56236c36 182 {
rgrover1 345:dfde56236c36 183 void * p_event_data;
rgrover1 345:dfde56236c36 184 uint16_t event_data_size;
rgrover1 345:dfde56236c36 185 app_sched_event_handler_t event_handler;
rgrover1 345:dfde56236c36 186
rgrover1 345:dfde56236c36 187 // Get next event (if any), and execute handler
rgrover1 345:dfde56236c36 188 while ((app_sched_event_get(&p_event_data, &event_data_size, &event_handler) == NRF_SUCCESS))
rgrover1 345:dfde56236c36 189 {
rgrover1 345:dfde56236c36 190 event_handler(p_event_data, event_data_size);
rgrover1 345:dfde56236c36 191 }
rgrover1 345:dfde56236c36 192 }