robo 8080
konashi/SBBLEのテスト
Fork of
BLE_LoopbackUART
by 
Bluetooth Low Energy
Embed:
(wiki syntax)
Show/hide line numbers
app_timer.cpp
00001 /* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved. 00002 * 00003 * The information contained herein is property of Nordic Semiconductor ASA. 00004 * Terms and conditions of usage are described in detail in NORDIC 00005 * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT. 00006 * 00007 * Licensees are granted free, non-transferable use of the information. NO 00008 * WARRANTY of ANY KIND is provided. This heading must NOT be removed from 00009 * the file. 00010 * 00011 */ 00012 00013 #include "app_timer.h " 00014 #include <stdlib.h> 00015 #include "nrf51.h" 00016 #include "nrf51_bitfields.h" 00017 #include "nrf_soc.h" 00018 #include "app_error.h " 00019 //#include "nrf_delay.h" 00020 #include "mbed.h" 00021 #include "app_util.h " 00022 #include "app_util_platform.h " 00023 00024 00025 #define RTC1_IRQ_PRI APP_IRQ_PRIORITY_LOW /**< Priority of the RTC1 interrupt (used for checking for timeouts and executing timeout handlers). */ 00026 #define SWI0_IRQ_PRI APP_IRQ_PRIORITY_LOW /**< Priority of the SWI0 interrupt (used for updating the timer list). */ 00027 00028 // The current design assumes that both interrupt handlers run at the same interrupt level. 00029 // If this is to be changed, protection must be added to prevent them from interrupting each other 00030 // (e.g. by using guard/trigger flags). 00031 STATIC_ASSERT(RTC1_IRQ_PRI == SWI0_IRQ_PRI); 00032 00033 #define MAX_RTC_COUNTER_VAL 0x00FFFFFF /**< Maximum value of the RTC counter. */ 00034 00035 #define APP_HIGH_USER_ID 0 /**< User Id for the Application High "user". */ 00036 #define APP_LOW_USER_ID 1 /**< User Id for the Application Low "user". */ 00037 #define THREAD_MODE_USER_ID 2 /**< User Id for the Thread Mode "user". */ 00038 00039 #define RTC_COMPARE_OFFSET_MIN 3 /**< Minimum offset between the current RTC counter value and the Capture Compare register. Although the nRF51 Series User Specification recommends this value to be 2, we use 3 to be safer.*/ 00040 00041 #define MAX_RTC_TASKS_DELAY 47 /**< Maximum delay until an RTC task is executed. */ 00042 00043 /**@brief Timer allocation state type. */ 00044 typedef enum 00045 { 00046 STATE_FREE, /**< The timer node is available. */ 00047 STATE_ALLOCATED /**< The timer node has been allocated. */ 00048 } timer_alloc_state_t; 00049 00050 /**@brief Timer node type. The nodes will be used form a linked list of running timers. */ 00051 typedef struct 00052 { 00053 timer_alloc_state_t state; /**< Timer allocation state. */ 00054 app_timer_mode_t mode; /**< Timer mode. */ 00055 uint32_t ticks_to_expire; /**< Number of ticks from previous timer interrupt to timer expiry. */ 00056 uint32_t ticks_at_start; /**< Current RTC counter value when the timer was started. */ 00057 uint32_t ticks_first_interval; /**< Number of ticks in the first timer interval. */ 00058 uint32_t ticks_periodic_interval; /**< Timer period (for repeating timers). */ 00059 bool is_running; /**< True if timer is running, False otherwise. */ 00060 app_timer_timeout_handler_t p_timeout_handler; /**< Pointer to function to be executed when the timer expires. */ 00061 void * p_context; /**< General purpose pointer. Will be passed to the timeout handler when the timer expires. */ 00062 app_timer_id_t next; /**< Id of next timer in list of running timers. */ 00063 } timer_node_t; 00064 00065 STATIC_ASSERT(sizeof(timer_node_t) <= APP_TIMER_NODE_SIZE); 00066 STATIC_ASSERT(sizeof(timer_node_t) % 4 == 0); 00067 00068 /**@brief Set of available timer operation types. */ 00069 typedef enum 00070 { 00071 TIMER_USER_OP_TYPE_NONE, /**< Invalid timer operation type. */ 00072 TIMER_USER_OP_TYPE_START, /**< Timer operation type Start. */ 00073 TIMER_USER_OP_TYPE_STOP, /**< Timer operation type Stop. */ 00074 TIMER_USER_OP_TYPE_STOP_ALL /**< Timer operation type Stop All. */ 00075 } timer_user_op_type_t; 00076 00077 /**@brief Structure describing a timer start operation. */ 00078 typedef struct 00079 { 00080 uint32_t ticks_at_start; /**< Current RTC counter value when the timer was started. */ 00081 uint32_t ticks_first_interval; /**< Number of ticks in the first timer interval. */ 00082 uint32_t ticks_periodic_interval; /**< Timer period (for repeating timers). */ 00083 void * p_context; /**< General purpose pointer. Will be passed to the timeout handler when the timer expires. */ 00084 } timer_user_op_start_t; 00085 00086 /**@brief Structure describing a timer operation. */ 00087 typedef struct 00088 { 00089 timer_user_op_type_t op_type; /**< Timer operation type. */ 00090 app_timer_id_t timer_id; /**< Id of timer on which the operation is to be performed. */ 00091 union 00092 { 00093 timer_user_op_start_t start; /**< Structure describing a timer start operation. */ 00094 } params; 00095 } timer_user_op_t; 00096 00097 STATIC_ASSERT(sizeof(timer_user_op_t) <= APP_TIMER_USER_OP_SIZE); 00098 STATIC_ASSERT(sizeof(timer_user_op_t) % 4 == 0); 00099 00100 /**@brief Structure describing a timer user. 00101 * 00102 * @details For each user of the timer module, there will be a timer operations queue. This queue 00103 * will hold timer operations issued by this user until the timer interrupt handler 00104 * processes these operations. For the current implementation, there will be one user for 00105 * each interrupt level available to the application (APP_HIGH, APP_LOW and THREAD_MODE), 00106 * but the module can easily be modified to e.g. have one queue per process when using an 00107 * RTOS. The purpose of the queues is to be able to have a completely lockless timer 00108 * implementation. 00109 */ 00110 typedef struct 00111 { 00112 uint8_t first; /**< Index of first entry to have been inserted in the queue (i.e. the next entry to be executed). */ 00113 uint8_t last; /**< Index of last entry to have been inserted in the queue. */ 00114 uint8_t user_op_queue_size; /**< Queue size. */ 00115 timer_user_op_t * p_user_op_queue; /**< Queue buffer. */ 00116 } timer_user_t; 00117 00118 STATIC_ASSERT(sizeof(timer_user_t) == APP_TIMER_USER_SIZE); 00119 STATIC_ASSERT(sizeof(timer_user_t) % 4 == 0); 00120 00121 /**@brief User id type. 00122 * 00123 * @details In the current implementation, this will automatically be generated from the current 00124 * interrupt level. 00125 */ 00126 typedef uint32_t timer_user_id_t; 00127 00128 #define TIMER_NULL ((app_timer_id_t)(0 - 1)) /**< Invalid timer id. */ 00129 #define CONTEXT_QUEUE_SIZE_MAX (2) /**< Timer internal elapsed ticks queue size. */ 00130 00131 static uint8_t m_node_array_size; /**< Size of timer node array. */ 00132 static timer_node_t * mp_nodes = NULL; /**< Array of timer nodes. */ 00133 static uint8_t m_user_array_size; /**< Size of timer user array. */ 00134 static timer_user_t * mp_users; /**< Array of timer users. */ 00135 static app_timer_id_t m_timer_id_head; /**< First timer in list of running timers. */ 00136 static uint32_t m_ticks_latest; /**< Last known RTC counter value. */ 00137 static uint32_t m_ticks_elapsed[CONTEXT_QUEUE_SIZE_MAX]; /**< Timer internal elapsed ticks queue. */ 00138 static uint8_t m_ticks_elapsed_q_read_ind; /**< Timer internal elapsed ticks queue read index. */ 00139 static uint8_t m_ticks_elapsed_q_write_ind; /**< Timer internal elapsed ticks queue write index. */ 00140 static app_timer_evt_schedule_func_t m_evt_schedule_func; /**< Pointer to function for propagating timeout events to the scheduler. */ 00141 00142 00143 /**@brief Function for initializing the RTC1 counter. 00144 * 00145 * @param[in] prescaler Value of the RTC1 PRESCALER register. Set to 0 for no prescaling. 00146 */ 00147 static void rtc1_init(uint32_t prescaler) 00148 { 00149 NRF_RTC1->PRESCALER = prescaler; 00150 NVIC_SetPriority(RTC1_IRQn, RTC1_IRQ_PRI); 00151 } 00152 00153 00154 /**@brief Function for starting the RTC1 timer. 00155 */ 00156 static void rtc1_start(void) 00157 { 00158 NRF_RTC1->EVTENSET = RTC_EVTEN_COMPARE0_Msk; 00159 NRF_RTC1->INTENSET = RTC_INTENSET_COMPARE0_Msk; 00160 00161 NVIC_ClearPendingIRQ(RTC1_IRQn); 00162 NVIC_EnableIRQ(RTC1_IRQn); 00163 00164 NRF_RTC1->TASKS_START = 1; 00165 wait(0.0000001 * MAX_RTC_TASKS_DELAY); 00166 } 00167 00168 00169 /**@brief Function for stopping the RTC1 timer. 00170 */ 00171 static void rtc1_stop(void) 00172 { 00173 NVIC_DisableIRQ(RTC1_IRQn); 00174 00175 NRF_RTC1->EVTENCLR = RTC_EVTEN_COMPARE0_Msk; 00176 NRF_RTC1->INTENCLR = RTC_INTENSET_COMPARE0_Msk; 00177 00178 NRF_RTC1->TASKS_STOP = 1; 00179 wait(0.0000001 * MAX_RTC_TASKS_DELAY); 00180 } 00181 00182 00183 /**@brief Function for returning the current value of the RTC1 counter. 00184 * 00185 * @return Current value of the RTC1 counter. 00186 */ 00187 static __INLINE uint32_t rtc1_counter_get(void) 00188 { 00189 return NRF_RTC1->COUNTER; 00190 } 00191 00192 00193 /**@brief Function for computing the difference between two RTC1 counter values. 00194 * 00195 * @return Number of ticks elapsed from ticks_old to ticks_now. 00196 */ 00197 static __INLINE uint32_t ticks_diff_get(uint32_t ticks_now, uint32_t ticks_old) 00198 { 00199 return ((ticks_now - ticks_old) & MAX_RTC_COUNTER_VAL); 00200 } 00201 00202 00203 /**@brief Function for setting the RTC1 Capture Compare register 0, and enabling the corresponding 00204 * event. 00205 * 00206 * @param[in] value New value of Capture Compare register 0. 00207 */ 00208 static __INLINE void rtc1_compare0_set(uint32_t value) 00209 { 00210 NRF_RTC1->CC[0] = value; 00211 } 00212 00213 00214 /**@brief Function for inserting a timer in the timer list. 00215 * 00216 * @param[in] timer_id Id of timer to insert. 00217 */ 00218 static void timer_list_insert(app_timer_id_t timer_id) 00219 { 00220 timer_node_t * p_timer = &mp_nodes[timer_id]; 00221 00222 if (m_timer_id_head == TIMER_NULL) 00223 { 00224 m_timer_id_head = timer_id; 00225 } 00226 else 00227 { 00228 if (p_timer->ticks_to_expire <= mp_nodes[m_timer_id_head].ticks_to_expire) 00229 { 00230 mp_nodes[m_timer_id_head].ticks_to_expire -= p_timer->ticks_to_expire; 00231 00232 p_timer->next = m_timer_id_head; 00233 m_timer_id_head = timer_id; 00234 } 00235 else 00236 { 00237 app_timer_id_t previous; 00238 app_timer_id_t current; 00239 uint32_t ticks_to_expire; 00240 00241 ticks_to_expire = p_timer->ticks_to_expire; 00242 previous = m_timer_id_head; 00243 current = m_timer_id_head; 00244 00245 while ((current != TIMER_NULL) && (ticks_to_expire > mp_nodes[current].ticks_to_expire)) 00246 { 00247 ticks_to_expire -= mp_nodes[current].ticks_to_expire; 00248 previous = current; 00249 current = mp_nodes[current].next; 00250 } 00251 00252 if (current != TIMER_NULL) 00253 { 00254 mp_nodes[current].ticks_to_expire -= ticks_to_expire; 00255 } 00256 00257 p_timer->ticks_to_expire = ticks_to_expire; 00258 p_timer->next = current; 00259 mp_nodes[previous].next = timer_id; 00260 } 00261 } 00262 } 00263 00264 00265 /**@brief Function for removing a timer from the timer queue. 00266 * 00267 * @param[in] timer_id Id of timer to remove. 00268 */ 00269 static void timer_list_remove(app_timer_id_t timer_id) 00270 { 00271 app_timer_id_t previous; 00272 app_timer_id_t current; 00273 uint32_t timeout; 00274 00275 // Find the timer's position in timer list 00276 previous = m_timer_id_head; 00277 current = previous; 00278 00279 while (current != TIMER_NULL) 00280 { 00281 if (current == timer_id) 00282 { 00283 break; 00284 } 00285 previous = current; 00286 current = mp_nodes[current].next; 00287 } 00288 00289 // Timer not in active list 00290 if (current == TIMER_NULL) 00291 { 00292 return; 00293 } 00294 00295 // Timer is the first in the list 00296 if (previous == current) 00297 { 00298 m_timer_id_head = mp_nodes[m_timer_id_head].next; 00299 } 00300 00301 // Remaining timeout between next timeout 00302 timeout = mp_nodes[current].ticks_to_expire; 00303 00304 // Link previous timer with next of this timer, i.e. removing the timer from list 00305 mp_nodes[previous].next = mp_nodes[current].next; 00306 00307 // If this is not the last timer, increment the next timer by this timer timeout 00308 current = mp_nodes[previous].next; 00309 if (current != TIMER_NULL) 00310 { 00311 mp_nodes[current].ticks_to_expire += timeout; 00312 } 00313 } 00314 00315 00316 /**@brief Function for scheduling a check for timeouts by generating a RTC1 interrupt. 00317 */ 00318 static void timer_timeouts_check_sched(void) 00319 { 00320 NVIC_SetPendingIRQ(RTC1_IRQn); 00321 } 00322 00323 00324 /**@brief Function for scheduling a timer list update by generating a SWI0 interrupt. 00325 */ 00326 static void timer_list_handler_sched(void) 00327 { 00328 NVIC_SetPendingIRQ(SWI0_IRQn); 00329 } 00330 00331 00332 /**@brief Function for executing an application timeout handler, either by calling it directly, or 00333 * by passing an event to the @ref app_scheduler. 00334 * 00335 * @param[in] p_timer Pointer to expired timer. 00336 */ 00337 static void timeout_handler_exec(timer_node_t * p_timer) 00338 { 00339 if (m_evt_schedule_func != NULL) 00340 { 00341 uint32_t err_code = m_evt_schedule_func(p_timer->p_timeout_handler, p_timer->p_context); 00342 APP_ERROR_CHECK(err_code); 00343 } 00344 else 00345 { 00346 p_timer->p_timeout_handler(p_timer->p_context); 00347 } 00348 } 00349 00350 00351 /**@brief Function for checking for expired timers. 00352 */ 00353 static void timer_timeouts_check(void) 00354 { 00355 // Handle expired of timer 00356 if (m_timer_id_head != TIMER_NULL) 00357 { 00358 app_timer_id_t timer_id; 00359 uint32_t ticks_elapsed; 00360 uint32_t ticks_expired; 00361 00362 // Initialize actual elapsed ticks being consumed to 0 00363 ticks_expired = 0; 00364 00365 // ticks_elapsed is collected here, job will use it 00366 ticks_elapsed = ticks_diff_get(rtc1_counter_get(), m_ticks_latest); 00367 00368 // Auto variable containing the head of timers expiring 00369 timer_id = m_timer_id_head; 00370 00371 // Expire all timers within ticks_elapsed and collect ticks_expired 00372 while (timer_id != TIMER_NULL) 00373 { 00374 timer_node_t * p_timer; 00375 00376 // Auto variable for current timer node 00377 p_timer = &mp_nodes[timer_id]; 00378 00379 // Do nothing if timer did not expire 00380 if (ticks_elapsed < p_timer->ticks_to_expire) 00381 { 00382 break; 00383 } 00384 00385 // Decrement ticks_elapsed and collect expired ticks 00386 ticks_elapsed -= p_timer->ticks_to_expire; 00387 ticks_expired += p_timer->ticks_to_expire; 00388 00389 // Move to next timer 00390 timer_id = p_timer->next; 00391 00392 // Execute Task 00393 timeout_handler_exec(p_timer); 00394 } 00395 00396 // Prepare to queue the ticks expired in the m_ticks_elapsed queue. 00397 if (m_ticks_elapsed_q_read_ind == m_ticks_elapsed_q_write_ind) 00398 { 00399 // The read index of the queue is equal to the write index. This means the new 00400 // value of ticks_expired should be stored at a new location in the m_ticks_elapsed 00401 // queue (which is implemented as a double buffer). 00402 00403 // Check if there will be a queue overflow. 00404 if (++m_ticks_elapsed_q_write_ind == CONTEXT_QUEUE_SIZE_MAX) 00405 { 00406 // There will be a queue overflow. Hence the write index should point to the start 00407 // of the queue. 00408 m_ticks_elapsed_q_write_ind = 0; 00409 } 00410 } 00411 00412 // Queue the ticks expired. 00413 m_ticks_elapsed[m_ticks_elapsed_q_write_ind] = ticks_expired; 00414 00415 timer_list_handler_sched(); 00416 } 00417 } 00418 00419 00420 /**@brief Function for acquiring the number of ticks elapsed. 00421 * 00422 * @param[out] p_ticks_elapsed Number of ticks elapsed. 00423 * 00424 * @return TRUE if elapsed ticks was read from queue, FALSE otherwise. 00425 */ 00426 static bool elapsed_ticks_acquire(uint32_t * p_ticks_elapsed) 00427 { 00428 // Pick the elapsed value from queue 00429 if (m_ticks_elapsed_q_read_ind != m_ticks_elapsed_q_write_ind) 00430 { 00431 // Dequeue elapsed value 00432 m_ticks_elapsed_q_read_ind++; 00433 if (m_ticks_elapsed_q_read_ind == CONTEXT_QUEUE_SIZE_MAX) 00434 { 00435 m_ticks_elapsed_q_read_ind = 0; 00436 } 00437 00438 *p_ticks_elapsed = m_ticks_elapsed[m_ticks_elapsed_q_read_ind]; 00439 00440 m_ticks_latest += *p_ticks_elapsed; 00441 m_ticks_latest &= MAX_RTC_COUNTER_VAL; 00442 00443 return true; 00444 } 00445 else 00446 { 00447 // No elapsed value in queue 00448 *p_ticks_elapsed = 0; 00449 return false; 00450 } 00451 } 00452 00453 00454 /**@brief Function for handling the timer list deletions. 00455 * 00456 * @return TRUE if Capture Compare register must be updated, FALSE otherwise. 00457 */ 00458 static bool list_deletions_handler(void) 00459 { 00460 app_timer_id_t timer_id_old_head; 00461 uint8_t user_id; 00462 00463 // Remember the old head, so as to decide if new compare needs to be set 00464 timer_id_old_head = m_timer_id_head; 00465 00466 user_id = m_user_array_size; 00467 while (user_id--) 00468 { 00469 timer_user_t * p_user = &mp_users[user_id]; 00470 uint8_t user_ops_first = p_user->first; 00471 00472 while (user_ops_first != p_user->last) 00473 { 00474 timer_node_t * p_timer; 00475 timer_user_op_t * p_user_op = &p_user->p_user_op_queue[user_ops_first]; 00476 00477 // Traverse to next operation in queue 00478 user_ops_first++; 00479 if (user_ops_first == p_user->user_op_queue_size) 00480 { 00481 user_ops_first = 0; 00482 } 00483 00484 switch (p_user_op->op_type) 00485 { 00486 case TIMER_USER_OP_TYPE_STOP: 00487 // Delete node if timer is running 00488 p_timer = &mp_nodes[p_user_op->timer_id]; 00489 if (p_timer->is_running) 00490 { 00491 timer_list_remove(p_user_op->timer_id); 00492 p_timer->is_running = false; 00493 } 00494 break; 00495 00496 case TIMER_USER_OP_TYPE_STOP_ALL: 00497 // Delete list of running timers, and mark all timers as not running 00498 while (m_timer_id_head != TIMER_NULL) 00499 { 00500 timer_node_t * p_head = &mp_nodes[m_timer_id_head]; 00501 00502 p_head->is_running = false; 00503 m_timer_id_head = p_head->next; 00504 } 00505 break; 00506 00507 default: 00508 // No implementation needed. 00509 break; 00510 } 00511 } 00512 } 00513 00514 // Detect change in head of the list 00515 return (m_timer_id_head != timer_id_old_head); 00516 } 00517 00518 00519 /**@brief Function for updating the timer list for expired timers. 00520 * 00521 * @param[in] ticks_elapsed Number of elapsed ticks. 00522 * @param[in] ticks_previous Previous known value of the RTC counter. 00523 * @param[out] p_restart_list_head List of repeating timers to be restarted. 00524 */ 00525 static void expired_timers_handler(uint32_t ticks_elapsed, 00526 uint32_t ticks_previous, 00527 app_timer_id_t * p_restart_list_head) 00528 { 00529 uint32_t ticks_expired = 0; 00530 00531 while (m_timer_id_head != TIMER_NULL) 00532 { 00533 timer_node_t * p_timer; 00534 app_timer_id_t id_expired; 00535 00536 // Auto variable for current timer node 00537 p_timer = &mp_nodes[m_timer_id_head]; 00538 00539 // Do nothing if timer did not expire 00540 if (ticks_elapsed < p_timer->ticks_to_expire) 00541 { 00542 p_timer->ticks_to_expire -= ticks_elapsed; 00543 break; 00544 } 00545 00546 // Decrement ticks_elapsed and collect expired ticks 00547 ticks_elapsed -= p_timer->ticks_to_expire; 00548 ticks_expired += p_timer->ticks_to_expire; 00549 00550 // Timer expired, set ticks_to_expire zero 00551 p_timer->ticks_to_expire = 0; 00552 p_timer->is_running = false; 00553 00554 // Remove the expired timer from head 00555 id_expired = m_timer_id_head; 00556 m_timer_id_head = p_timer->next; 00557 00558 // Timer will be restarted if periodic 00559 if (p_timer->ticks_periodic_interval != 0) 00560 { 00561 p_timer->ticks_at_start = (ticks_previous + ticks_expired) & MAX_RTC_COUNTER_VAL; 00562 p_timer->ticks_first_interval = p_timer->ticks_periodic_interval; 00563 p_timer->next = *p_restart_list_head; 00564 *p_restart_list_head = id_expired; 00565 } 00566 } 00567 } 00568 00569 00570 /**@brief Function for handling timer list insertions. 00571 * 00572 * @param[in] p_restart_list_head List of repeating timers to be restarted. 00573 * 00574 * @return TRUE if Capture Compare register must be updated, FALSE otherwise. 00575 */ 00576 static bool list_insertions_handler(app_timer_id_t restart_list_head) 00577 { 00578 app_timer_id_t timer_id_old_head; 00579 uint8_t user_id; 00580 00581 // Remember the old head, so as to decide if new compare needs to be set 00582 timer_id_old_head = m_timer_id_head; 00583 00584 user_id = m_user_array_size; 00585 while (user_id--) 00586 { 00587 timer_user_t * p_user = &mp_users[user_id]; 00588 00589 // Handle insertions of timers 00590 while ((restart_list_head != TIMER_NULL) || (p_user->first != p_user->last)) 00591 { 00592 app_timer_id_t id_start; 00593 timer_node_t * p_timer; 00594 00595 if (restart_list_head != TIMER_NULL) 00596 { 00597 id_start = restart_list_head; 00598 p_timer = &mp_nodes[id_start]; 00599 restart_list_head = p_timer->next; 00600 } 00601 else 00602 { 00603 timer_user_op_t * p_user_op = &p_user->p_user_op_queue[p_user->first]; 00604 00605 p_user->first++; 00606 if (p_user->first == p_user->user_op_queue_size) 00607 { 00608 p_user->first = 0; 00609 } 00610 00611 id_start = p_user_op->timer_id; 00612 p_timer = &mp_nodes[id_start]; 00613 00614 if ((p_user_op->op_type != TIMER_USER_OP_TYPE_START) || p_timer->is_running) 00615 { 00616 continue; 00617 } 00618 00619 p_timer->ticks_at_start = p_user_op->params.start.ticks_at_start; 00620 p_timer->ticks_first_interval = p_user_op->params.start.ticks_first_interval; 00621 p_timer->ticks_periodic_interval = p_user_op->params.start.ticks_periodic_interval; 00622 p_timer->p_context = p_user_op->params.start.p_context; 00623 } 00624 00625 // Prepare the node to be inserted 00626 if ( 00627 ((p_timer->ticks_at_start - m_ticks_latest) & MAX_RTC_COUNTER_VAL) 00628 < 00629 (MAX_RTC_COUNTER_VAL / 2) 00630 ) 00631 { 00632 p_timer->ticks_to_expire = ticks_diff_get(p_timer->ticks_at_start, m_ticks_latest) + 00633 p_timer->ticks_first_interval; 00634 } 00635 else 00636 { 00637 uint32_t delta_current_start; 00638 00639 delta_current_start = ticks_diff_get(m_ticks_latest, p_timer->ticks_at_start); 00640 if (p_timer->ticks_first_interval > delta_current_start) 00641 { 00642 p_timer->ticks_to_expire = p_timer->ticks_first_interval - delta_current_start; 00643 } 00644 else 00645 { 00646 p_timer->ticks_to_expire = 0; 00647 } 00648 } 00649 00650 p_timer->ticks_at_start = 0; 00651 p_timer->ticks_first_interval = 0; 00652 p_timer->is_running = true; 00653 p_timer->next = TIMER_NULL; 00654 00655 // Insert into list 00656 timer_list_insert(id_start); 00657 } 00658 } 00659 00660 return (m_timer_id_head != timer_id_old_head); 00661 } 00662 00663 00664 /**@brief Function for updating the Capture Compare register. 00665 */ 00666 static void compare_reg_update(app_timer_id_t timer_id_head_old) 00667 { 00668 // Setup the timeout for timers on the head of the list 00669 if (m_timer_id_head != TIMER_NULL) 00670 { 00671 uint32_t ticks_to_expire = mp_nodes[m_timer_id_head].ticks_to_expire; 00672 uint32_t pre_counter_val = rtc1_counter_get(); 00673 uint32_t cc = m_ticks_latest; 00674 uint32_t ticks_elapsed = ticks_diff_get(pre_counter_val, cc) + RTC_COMPARE_OFFSET_MIN; 00675 00676 if (timer_id_head_old == TIMER_NULL) 00677 { 00678 // No timers were already running, start RTC 00679 rtc1_start(); 00680 } 00681 00682 cc += (ticks_elapsed < ticks_to_expire) ? ticks_to_expire : ticks_elapsed; 00683 cc &= MAX_RTC_COUNTER_VAL; 00684 00685 rtc1_compare0_set(cc); 00686 00687 uint32_t post_counter_val = rtc1_counter_get(); 00688 00689 if ( 00690 (ticks_diff_get(post_counter_val, pre_counter_val) + RTC_COMPARE_OFFSET_MIN) 00691 > 00692 ticks_diff_get(cc, pre_counter_val) 00693 ) 00694 { 00695 // When this happens the COMPARE event may not be triggered by the RTC. 00696 // The nRF51 Series User Specification states that if the COUNTER value is N 00697 // (i.e post_counter_val = N), writing N or N+1 to a CC register may not trigger a 00698 // COMPARE event. Hence the RTC interrupt is forcefully pended by calling the following 00699 // function. 00700 timer_timeouts_check_sched(); 00701 } 00702 } 00703 else 00704 { 00705 // No timers are running, stop RTC 00706 rtc1_stop(); 00707 } 00708 } 00709 00710 00711 /**@brief Function for handling changes to the timer list. 00712 */ 00713 static void timer_list_handler(void) 00714 { 00715 app_timer_id_t restart_list_head = TIMER_NULL; 00716 uint32_t ticks_elapsed; 00717 uint32_t ticks_previous; 00718 bool ticks_have_elapsed; 00719 bool compare_update; 00720 app_timer_id_t timer_id_head_old; 00721 00722 // Back up the previous known tick and previous list head 00723 ticks_previous = m_ticks_latest; 00724 timer_id_head_old = m_timer_id_head; 00725 00726 // Get number of elapsed ticks 00727 ticks_have_elapsed = elapsed_ticks_acquire(&ticks_elapsed); 00728 00729 // Handle list deletions 00730 compare_update = list_deletions_handler(); 00731 00732 // Handle expired timers 00733 if (ticks_have_elapsed) 00734 { 00735 expired_timers_handler(ticks_elapsed, ticks_previous, &restart_list_head); 00736 compare_update = true; 00737 } 00738 00739 // Handle list insertions 00740 if (list_insertions_handler(restart_list_head)) 00741 { 00742 compare_update = true; 00743 } 00744 00745 // Update compare register if necessary 00746 if (compare_update) 00747 { 00748 compare_reg_update(timer_id_head_old); 00749 } 00750 } 00751 00752 00753 /**@brief Function for enqueueing a new operations queue entry. 00754 * 00755 * @param[in] p_user User that the entry is to be enqueued for. 00756 * @param[in] last_index Index of the next last index to be enqueued. 00757 */ 00758 static void user_op_enque(timer_user_t * p_user, app_timer_id_t last_index) 00759 { 00760 p_user->last = last_index; 00761 } 00762 00763 00764 /**@brief Function for allocating a new operations queue entry. 00765 * 00766 * @param[in] p_user User that the entry is to be allocated for. 00767 * @param[out] p_last_index Index of the next last index to be enqueued. 00768 * 00769 * @return Pointer to allocated queue entry, or NULL if queue is full. 00770 */ 00771 static timer_user_op_t * user_op_alloc(timer_user_t * p_user, app_timer_id_t * p_last_index) 00772 { 00773 app_timer_id_t last; 00774 timer_user_op_t * p_user_op; 00775 00776 last = p_user->last + 1; 00777 if (last == p_user->user_op_queue_size) 00778 { 00779 // Overflow case. 00780 last = 0; 00781 } 00782 if (last == p_user->first) 00783 { 00784 // Queue is full. 00785 return NULL; 00786 } 00787 00788 *p_last_index = last; 00789 p_user_op = &p_user->p_user_op_queue[p_user->last]; 00790 00791 return p_user_op; 00792 } 00793 00794 00795 /**@brief Function for scheduling a Timer Start operation. 00796 * 00797 * @param[in] user_id Id of user calling this function. 00798 * @param[in] timer_id Id of timer to start. 00799 * @param[in] timeout_initial Time (in ticks) to first timer expiry. 00800 * @param[in] timeout_periodic Time (in ticks) between periodic expiries. 00801 * @param[in] p_context General purpose pointer. Will be passed to the timeout handler when 00802 * the timer expires. 00803 * @return NRF_SUCCESS on success, otherwise an error code. 00804 */ 00805 static uint32_t timer_start_op_schedule(timer_user_id_t user_id, 00806 app_timer_id_t timer_id, 00807 uint32_t timeout_initial, 00808 uint32_t timeout_periodic, 00809 void * p_context) 00810 { 00811 app_timer_id_t last_index; 00812 00813 timer_user_op_t * p_user_op = user_op_alloc(&mp_users[user_id], &last_index); 00814 if (p_user_op == NULL) 00815 { 00816 return NRF_ERROR_NO_MEM; 00817 } 00818 00819 p_user_op->op_type = TIMER_USER_OP_TYPE_START; 00820 p_user_op->timer_id = timer_id; 00821 p_user_op->params.start.ticks_at_start = rtc1_counter_get(); 00822 p_user_op->params.start.ticks_first_interval = timeout_initial; 00823 p_user_op->params.start.ticks_periodic_interval = timeout_periodic; 00824 p_user_op->params.start.p_context = p_context; 00825 00826 user_op_enque(&mp_users[user_id], last_index); 00827 00828 timer_list_handler_sched(); 00829 00830 return NRF_SUCCESS; 00831 } 00832 00833 00834 /**@brief Function for scheduling a Timer Stop operation. 00835 * 00836 * @param[in] user_id Id of user calling this function. 00837 * @param[in] timer_id Id of timer to stop. 00838 * 00839 * @return NRF_SUCCESS on successful scheduling a timer stop operation. NRF_ERROR_NO_MEM when there 00840 * is no memory left to schedule the timer stop operation. 00841 */ 00842 static uint32_t timer_stop_op_schedule(timer_user_id_t user_id, app_timer_id_t timer_id) 00843 { 00844 app_timer_id_t last_index; 00845 00846 timer_user_op_t * p_user_op = user_op_alloc(&mp_users[user_id], &last_index); 00847 if (p_user_op == NULL) 00848 { 00849 return NRF_ERROR_NO_MEM; 00850 } 00851 00852 p_user_op->op_type = TIMER_USER_OP_TYPE_STOP; 00853 p_user_op->timer_id = timer_id; 00854 00855 user_op_enque(&mp_users[user_id], last_index); 00856 00857 timer_list_handler_sched(); 00858 00859 return NRF_SUCCESS; 00860 } 00861 00862 00863 /**@brief Function for scheduling a Timer Stop All operation. 00864 * 00865 * @param[in] user_id Id of user calling this function. 00866 */ 00867 static uint32_t timer_stop_all_op_schedule(timer_user_id_t user_id) 00868 { 00869 app_timer_id_t last_index; 00870 00871 timer_user_op_t * p_user_op = user_op_alloc(&mp_users[user_id], &last_index); 00872 if (p_user_op == NULL) 00873 { 00874 return NRF_ERROR_NO_MEM; 00875 } 00876 00877 p_user_op->op_type = TIMER_USER_OP_TYPE_STOP_ALL; 00878 p_user_op->timer_id = TIMER_NULL; 00879 00880 user_op_enque(&mp_users[user_id], last_index); 00881 00882 timer_list_handler_sched(); 00883 00884 return NRF_SUCCESS; 00885 } 00886 00887 00888 /**@brief Function for handling the RTC1 interrupt. 00889 * 00890 * @details Checks for timeouts, and executes timeout handlers for expired timers. 00891 */ 00892 extern "C" void RTC1_IRQHandler(void) 00893 { 00894 // Clear all events (also unexpected ones) 00895 NRF_RTC1->EVENTS_COMPARE[0] = 0; 00896 NRF_RTC1->EVENTS_COMPARE[1] = 0; 00897 NRF_RTC1->EVENTS_COMPARE[2] = 0; 00898 NRF_RTC1->EVENTS_COMPARE[3] = 0; 00899 NRF_RTC1->EVENTS_TICK = 0; 00900 NRF_RTC1->EVENTS_OVRFLW = 0; 00901 00902 // Check for expired timers 00903 timer_timeouts_check(); 00904 } 00905 00906 /**@brief Function for handling the SWI0 interrupt. 00907 * 00908 * @details Performs all updates to the timer list. 00909 */ 00910 extern "C" void SWI0_IRQHandler(void) 00911 { 00912 timer_list_handler(); 00913 } 00914 00915 uint32_t app_timer_init(uint32_t prescaler, 00916 uint8_t max_timers, 00917 uint8_t op_queues_size, 00918 void * p_buffer, 00919 app_timer_evt_schedule_func_t evt_schedule_func) 00920 { 00921 int i; 00922 00923 // Check that buffer is correctly aligned 00924 if (!is_word_aligned(p_buffer)) 00925 { 00926 return NRF_ERROR_INVALID_PARAM; 00927 } 00928 // Check for NULL buffer 00929 if (p_buffer == NULL) 00930 { 00931 return NRF_ERROR_INVALID_PARAM; 00932 } 00933 00934 // Stop RTC to prevent any running timers from expiring (in case of reinitialization) 00935 rtc1_stop(); 00936 00937 m_evt_schedule_func = evt_schedule_func; 00938 00939 // Initialize timer node array 00940 m_node_array_size = max_timers; 00941 mp_nodes = (timer_node_t *) p_buffer; 00942 00943 for (i = 0; i < max_timers; i++) 00944 { 00945 mp_nodes[i].state = STATE_FREE; 00946 mp_nodes[i].is_running = false; 00947 } 00948 00949 // Skip timer node array 00950 p_buffer = &((uint8_t *)p_buffer)[max_timers * sizeof(timer_node_t)]; 00951 00952 // Initialize users array 00953 m_user_array_size = APP_TIMER_INT_LEVELS; 00954 mp_users = (timer_user_t *) p_buffer; 00955 00956 // Skip user array 00957 p_buffer = &((uint8_t *)p_buffer)[APP_TIMER_INT_LEVELS * sizeof(timer_user_t)]; 00958 00959 // Initialize operation queues 00960 for (i = 0; i < APP_TIMER_INT_LEVELS; i++) 00961 { 00962 timer_user_t * p_user = &mp_users[i]; 00963 00964 p_user->first = 0; 00965 p_user->last = 0; 00966 p_user->user_op_queue_size = op_queues_size; 00967 p_user->p_user_op_queue = (timer_user_op_t *) p_buffer; 00968 00969 // Skip operation queue 00970 p_buffer = &((uint8_t *)p_buffer)[op_queues_size * sizeof(timer_user_op_t)]; 00971 } 00972 00973 m_timer_id_head = TIMER_NULL; 00974 m_ticks_elapsed_q_read_ind = 0; 00975 m_ticks_elapsed_q_write_ind = 0; 00976 00977 NVIC_ClearPendingIRQ(SWI0_IRQn); 00978 NVIC_SetPriority(SWI0_IRQn, SWI0_IRQ_PRI); 00979 NVIC_EnableIRQ(SWI0_IRQn); 00980 00981 rtc1_init(prescaler); 00982 00983 m_ticks_latest = rtc1_counter_get(); 00984 00985 return NRF_SUCCESS; 00986 } 00987 00988 00989 uint32_t app_timer_create(app_timer_id_t * p_timer_id, 00990 app_timer_mode_t mode, 00991 app_timer_timeout_handler_t timeout_handler) 00992 { 00993 int i; 00994 00995 // Check state and parameters 00996 if (mp_nodes == NULL) 00997 { 00998 return NRF_ERROR_INVALID_STATE; 00999 } 01000 if (timeout_handler == NULL) 01001 { 01002 return NRF_ERROR_INVALID_PARAM; 01003 } 01004 if (p_timer_id == NULL) 01005 { 01006 return NRF_ERROR_INVALID_PARAM; 01007 } 01008 01009 // Find free timer 01010 for (i = 0; i < m_node_array_size; i++) 01011 { 01012 if (mp_nodes[i].state == STATE_FREE) 01013 { 01014 mp_nodes[i].state = STATE_ALLOCATED; 01015 mp_nodes[i].mode = mode; 01016 mp_nodes[i].p_timeout_handler = timeout_handler; 01017 01018 *p_timer_id = i; 01019 return NRF_SUCCESS; 01020 } 01021 } 01022 01023 return NRF_ERROR_NO_MEM; 01024 } 01025 01026 01027 /**@brief Function for creating a timer user id from the current interrupt level. 01028 * 01029 * @return Timer user id. 01030 */ 01031 static timer_user_id_t user_id_get(void) 01032 { 01033 timer_user_id_t ret; 01034 01035 STATIC_ASSERT(APP_TIMER_INT_LEVELS == 3); 01036 01037 switch (current_int_priority_get()) 01038 { 01039 case APP_IRQ_PRIORITY_HIGH: 01040 ret = APP_HIGH_USER_ID; 01041 break; 01042 01043 case APP_IRQ_PRIORITY_LOW: 01044 ret = APP_LOW_USER_ID; 01045 break; 01046 01047 default: 01048 ret = THREAD_MODE_USER_ID; 01049 break; 01050 } 01051 01052 return ret; 01053 } 01054 01055 01056 uint32_t app_timer_start(app_timer_id_t timer_id, uint32_t timeout_ticks, void * p_context) 01057 { 01058 uint32_t timeout_periodic; 01059 01060 // Check state and parameters 01061 if (mp_nodes == NULL) 01062 { 01063 return NRF_ERROR_INVALID_STATE; 01064 } 01065 if ((timer_id >= m_node_array_size) || (timeout_ticks < APP_TIMER_MIN_TIMEOUT_TICKS)) 01066 { 01067 return NRF_ERROR_INVALID_PARAM; 01068 } 01069 if (mp_nodes[timer_id].state != STATE_ALLOCATED) 01070 { 01071 return NRF_ERROR_INVALID_STATE; 01072 } 01073 01074 // Schedule timer start operation 01075 timeout_periodic = (mp_nodes[timer_id].mode == APP_TIMER_MODE_REPEATED) ? timeout_ticks : 0; 01076 01077 return timer_start_op_schedule(user_id_get(), 01078 timer_id, 01079 timeout_ticks, 01080 timeout_periodic, 01081 p_context); 01082 } 01083 01084 01085 uint32_t app_timer_stop(app_timer_id_t timer_id) 01086 { 01087 // Check state and parameters 01088 if (mp_nodes == NULL) 01089 { 01090 return NRF_ERROR_INVALID_STATE; 01091 } 01092 if (timer_id >= m_node_array_size) 01093 { 01094 return NRF_ERROR_INVALID_PARAM; 01095 } 01096 if (mp_nodes[timer_id].state != STATE_ALLOCATED) 01097 { 01098 return NRF_ERROR_INVALID_STATE; 01099 } 01100 01101 // Schedule timer stop operation 01102 return timer_stop_op_schedule(user_id_get(), timer_id); 01103 } 01104 01105 01106 uint32_t app_timer_stop_all(void) 01107 { 01108 // Check state 01109 if (mp_nodes == NULL) 01110 { 01111 return NRF_ERROR_INVALID_STATE; 01112 } 01113 01114 return timer_stop_all_op_schedule(user_id_get()); 01115 } 01116 01117 01118 uint32_t app_timer_cnt_get(uint32_t * p_ticks) 01119 { 01120 *p_ticks = rtc1_counter_get(); 01121 return NRF_SUCCESS; 01122 } 01123 01124 01125 uint32_t app_timer_cnt_diff_compute(uint32_t ticks_to, 01126 uint32_t ticks_from, 01127 uint32_t * p_ticks_diff) 01128 { 01129 *p_ticks_diff = ticks_diff_get(ticks_to, ticks_from); 01130 return NRF_SUCCESS; 01131 }
Generated on Tue Jul 12 2022 20:35:45 by
1.7.2