Denislam Valeev / Mbed OS Nucleo_rtos_basic

1

mbed-os/hal/mbed_ticker_api.c@0:e056ac8fecf8, 2018-03-13 (annotated)

Committer:
valeyev
Date:
Tue Mar 13 07:17:50 2018 +0000
Revision:
0:e056ac8fecf8
looking for...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
valeyev 0:e056ac8fecf8 1 /* mbed Microcontroller Library
valeyev 0:e056ac8fecf8 2 * Copyright (c) 2015 ARM Limited
valeyev 0:e056ac8fecf8 3 *
valeyev 0:e056ac8fecf8 4 * Licensed under the Apache License, Version 2.0 (the "License");
valeyev 0:e056ac8fecf8 5 * you may not use this file except in compliance with the License.
valeyev 0:e056ac8fecf8 6 * You may obtain a copy of the License at
valeyev 0:e056ac8fecf8 7 *
valeyev 0:e056ac8fecf8 8 * http://www.apache.org/licenses/LICENSE-2.0
valeyev 0:e056ac8fecf8 9 *
valeyev 0:e056ac8fecf8 10 * Unless required by applicable law or agreed to in writing, software
valeyev 0:e056ac8fecf8 11 * distributed under the License is distributed on an "AS IS" BASIS,
valeyev 0:e056ac8fecf8 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
valeyev 0:e056ac8fecf8 13 * See the License for the specific language governing permissions and
valeyev 0:e056ac8fecf8 14 * limitations under the License.
valeyev 0:e056ac8fecf8 15 */
valeyev 0:e056ac8fecf8 16 #include <stdio.h>
valeyev 0:e056ac8fecf8 17 #include <stddef.h>
valeyev 0:e056ac8fecf8 18 #include "hal/ticker_api.h"
valeyev 0:e056ac8fecf8 19 #include "platform/mbed_critical.h"
valeyev 0:e056ac8fecf8 20 #include "mbed_assert.h"
valeyev 0:e056ac8fecf8 21
valeyev 0:e056ac8fecf8 22 static void schedule_interrupt(const ticker_data_t *const ticker);
valeyev 0:e056ac8fecf8 23 static void update_present_time(const ticker_data_t *const ticker);
valeyev 0:e056ac8fecf8 24
valeyev 0:e056ac8fecf8 25 /*
valeyev 0:e056ac8fecf8 26 * Initialize a ticker instance.
valeyev 0:e056ac8fecf8 27 */
valeyev 0:e056ac8fecf8 28 static void initialize(const ticker_data_t *ticker)
valeyev 0:e056ac8fecf8 29 {
valeyev 0:e056ac8fecf8 30 // return if the queue has already been initialized, in that case the
valeyev 0:e056ac8fecf8 31 // interface used by the queue is already initialized.
valeyev 0:e056ac8fecf8 32 if (ticker->queue->initialized) {
valeyev 0:e056ac8fecf8 33 return;
valeyev 0:e056ac8fecf8 34 }
valeyev 0:e056ac8fecf8 35
valeyev 0:e056ac8fecf8 36 ticker->interface->init();
valeyev 0:e056ac8fecf8 37
valeyev 0:e056ac8fecf8 38 const ticker_info_t *info = ticker->interface->get_info();
valeyev 0:e056ac8fecf8 39 uint32_t frequency = info->frequency;
valeyev 0:e056ac8fecf8 40 if (info->frequency == 0) {
valeyev 0:e056ac8fecf8 41 MBED_ASSERT(0);
valeyev 0:e056ac8fecf8 42 frequency = 1000000;
valeyev 0:e056ac8fecf8 43 }
valeyev 0:e056ac8fecf8 44
valeyev 0:e056ac8fecf8 45 uint32_t bits = info->bits;
valeyev 0:e056ac8fecf8 46 if ((info->bits > 32) || (info->bits < 4)) {
valeyev 0:e056ac8fecf8 47 MBED_ASSERT(0);
valeyev 0:e056ac8fecf8 48 bits = 32;
valeyev 0:e056ac8fecf8 49 }
valeyev 0:e056ac8fecf8 50 uint32_t max_delta = 0x7 << (bits - 4); // 7/16th
valeyev 0:e056ac8fecf8 51 uint64_t max_delta_us =
valeyev 0:e056ac8fecf8 52 ((uint64_t)max_delta * 1000000 + frequency - 1) / frequency;
valeyev 0:e056ac8fecf8 53
valeyev 0:e056ac8fecf8 54 ticker->queue->event_handler = NULL;
valeyev 0:e056ac8fecf8 55 ticker->queue->head = NULL;
valeyev 0:e056ac8fecf8 56 ticker->queue->tick_last_read = ticker->interface->read();
valeyev 0:e056ac8fecf8 57 ticker->queue->tick_remainder = 0;
valeyev 0:e056ac8fecf8 58 ticker->queue->frequency = frequency;
valeyev 0:e056ac8fecf8 59 ticker->queue->bitmask = ((uint64_t)1 << bits) - 1;
valeyev 0:e056ac8fecf8 60 ticker->queue->max_delta = max_delta;
valeyev 0:e056ac8fecf8 61 ticker->queue->max_delta_us = max_delta_us;
valeyev 0:e056ac8fecf8 62 ticker->queue->present_time = 0;
valeyev 0:e056ac8fecf8 63 ticker->queue->initialized = true;
valeyev 0:e056ac8fecf8 64
valeyev 0:e056ac8fecf8 65 update_present_time(ticker);
valeyev 0:e056ac8fecf8 66 schedule_interrupt(ticker);
valeyev 0:e056ac8fecf8 67 }
valeyev 0:e056ac8fecf8 68
valeyev 0:e056ac8fecf8 69 /**
valeyev 0:e056ac8fecf8 70 * Set the event handler function of a ticker instance.
valeyev 0:e056ac8fecf8 71 */
valeyev 0:e056ac8fecf8 72 static void set_handler(const ticker_data_t *const ticker, ticker_event_handler handler)
valeyev 0:e056ac8fecf8 73 {
valeyev 0:e056ac8fecf8 74 ticker->queue->event_handler = handler;
valeyev 0:e056ac8fecf8 75 }
valeyev 0:e056ac8fecf8 76
valeyev 0:e056ac8fecf8 77 /*
valeyev 0:e056ac8fecf8 78 * Convert a 32 bit timestamp into a 64 bit timestamp.
valeyev 0:e056ac8fecf8 79 *
valeyev 0:e056ac8fecf8 80 * A 64 bit timestamp is used as the point of time of reference while the
valeyev 0:e056ac8fecf8 81 * timestamp to convert is relative to this point of time.
valeyev 0:e056ac8fecf8 82 *
valeyev 0:e056ac8fecf8 83 * The lower 32 bits of the timestamp returned will be equal to the timestamp to
valeyev 0:e056ac8fecf8 84 * convert.
valeyev 0:e056ac8fecf8 85 *
valeyev 0:e056ac8fecf8 86 * If the timestamp to convert is less than the lower 32 bits of the time
valeyev 0:e056ac8fecf8 87 * reference then the timestamp to convert is seen as an overflowed value and
valeyev 0:e056ac8fecf8 88 * the upper 32 bit of the timestamp returned will be equal to the upper 32 bit
valeyev 0:e056ac8fecf8 89 * of the reference point + 1.
valeyev 0:e056ac8fecf8 90 * Otherwise, the upper 32 bit returned will be equal to the upper 32 bit of the
valeyev 0:e056ac8fecf8 91 * reference point.
valeyev 0:e056ac8fecf8 92 *
valeyev 0:e056ac8fecf8 93 * @param ref: The 64 bit timestamp of reference.
valeyev 0:e056ac8fecf8 94 * @param timestamp: The timestamp to convert.
valeyev 0:e056ac8fecf8 95 */
valeyev 0:e056ac8fecf8 96 static us_timestamp_t convert_timestamp(us_timestamp_t ref, timestamp_t timestamp)
valeyev 0:e056ac8fecf8 97 {
valeyev 0:e056ac8fecf8 98 bool overflow = timestamp < ((timestamp_t) ref) ? true : false;
valeyev 0:e056ac8fecf8 99
valeyev 0:e056ac8fecf8 100 us_timestamp_t result = (ref & ~((us_timestamp_t)UINT32_MAX)) | timestamp;
valeyev 0:e056ac8fecf8 101 if (overflow) {
valeyev 0:e056ac8fecf8 102 result += (1ULL<<32);
valeyev 0:e056ac8fecf8 103 }
valeyev 0:e056ac8fecf8 104
valeyev 0:e056ac8fecf8 105 return result;
valeyev 0:e056ac8fecf8 106 }
valeyev 0:e056ac8fecf8 107
valeyev 0:e056ac8fecf8 108 /**
valeyev 0:e056ac8fecf8 109 * Update the present timestamp value of a ticker.
valeyev 0:e056ac8fecf8 110 */
valeyev 0:e056ac8fecf8 111 static void update_present_time(const ticker_data_t *const ticker)
valeyev 0:e056ac8fecf8 112 {
valeyev 0:e056ac8fecf8 113 ticker_event_queue_t *queue = ticker->queue;
valeyev 0:e056ac8fecf8 114 uint32_t ticker_time = ticker->interface->read();
valeyev 0:e056ac8fecf8 115 if (ticker_time == ticker->queue->tick_last_read) {
valeyev 0:e056ac8fecf8 116 // No work to do
valeyev 0:e056ac8fecf8 117 return;
valeyev 0:e056ac8fecf8 118 }
valeyev 0:e056ac8fecf8 119
valeyev 0:e056ac8fecf8 120 uint64_t elapsed_ticks = (ticker_time - queue->tick_last_read) & queue->bitmask;
valeyev 0:e056ac8fecf8 121 queue->tick_last_read = ticker_time;
valeyev 0:e056ac8fecf8 122
valeyev 0:e056ac8fecf8 123 uint64_t elapsed_us;
valeyev 0:e056ac8fecf8 124 if (1000000 == queue->frequency) {
valeyev 0:e056ac8fecf8 125 // Optimized for 1MHz
valeyev 0:e056ac8fecf8 126
valeyev 0:e056ac8fecf8 127 elapsed_us = elapsed_ticks;
valeyev 0:e056ac8fecf8 128 } else if (32768 == queue->frequency) {
valeyev 0:e056ac8fecf8 129 // Optimized for 32KHz
valeyev 0:e056ac8fecf8 130
valeyev 0:e056ac8fecf8 131 uint64_t us_x_ticks = elapsed_ticks * 1000000;
valeyev 0:e056ac8fecf8 132 elapsed_us = us_x_ticks >> 15;
valeyev 0:e056ac8fecf8 133
valeyev 0:e056ac8fecf8 134 // Update remainder
valeyev 0:e056ac8fecf8 135 queue->tick_remainder += us_x_ticks - (elapsed_us << 15);
valeyev 0:e056ac8fecf8 136 if (queue->tick_remainder >= queue->frequency) {
valeyev 0:e056ac8fecf8 137 elapsed_us += 1;
valeyev 0:e056ac8fecf8 138 queue->tick_remainder -= queue->frequency;
valeyev 0:e056ac8fecf8 139 }
valeyev 0:e056ac8fecf8 140 } else {
valeyev 0:e056ac8fecf8 141 // General case
valeyev 0:e056ac8fecf8 142
valeyev 0:e056ac8fecf8 143 uint64_t us_x_ticks = elapsed_ticks * 1000000;
valeyev 0:e056ac8fecf8 144 elapsed_us = us_x_ticks / queue->frequency;
valeyev 0:e056ac8fecf8 145
valeyev 0:e056ac8fecf8 146 // Update remainder
valeyev 0:e056ac8fecf8 147 queue->tick_remainder += us_x_ticks - elapsed_us * queue->frequency;
valeyev 0:e056ac8fecf8 148 if (queue->tick_remainder >= queue->frequency) {
valeyev 0:e056ac8fecf8 149 elapsed_us += 1;
valeyev 0:e056ac8fecf8 150 queue->tick_remainder -= queue->frequency;
valeyev 0:e056ac8fecf8 151 }
valeyev 0:e056ac8fecf8 152 }
valeyev 0:e056ac8fecf8 153
valeyev 0:e056ac8fecf8 154 // Update current time
valeyev 0:e056ac8fecf8 155 queue->present_time += elapsed_us;
valeyev 0:e056ac8fecf8 156 }
valeyev 0:e056ac8fecf8 157
valeyev 0:e056ac8fecf8 158 /**
valeyev 0:e056ac8fecf8 159 * Given the absolute timestamp compute the hal tick timestamp.
valeyev 0:e056ac8fecf8 160 */
valeyev 0:e056ac8fecf8 161 static timestamp_t compute_tick(const ticker_data_t *const ticker, us_timestamp_t timestamp)
valeyev 0:e056ac8fecf8 162 {
valeyev 0:e056ac8fecf8 163 ticker_event_queue_t *queue = ticker->queue;
valeyev 0:e056ac8fecf8 164 us_timestamp_t delta_us = timestamp - queue->present_time;
valeyev 0:e056ac8fecf8 165
valeyev 0:e056ac8fecf8 166 timestamp_t delta = ticker->queue->max_delta;
valeyev 0:e056ac8fecf8 167 if (delta_us <= ticker->queue->max_delta_us) {
valeyev 0:e056ac8fecf8 168 // Checking max_delta_us ensures the operation will not overflow
valeyev 0:e056ac8fecf8 169
valeyev 0:e056ac8fecf8 170 if (1000000 == queue->frequency) {
valeyev 0:e056ac8fecf8 171 // Optimized for 1MHz
valeyev 0:e056ac8fecf8 172
valeyev 0:e056ac8fecf8 173 delta = delta_us;
valeyev 0:e056ac8fecf8 174 if (delta > ticker->queue->max_delta) {
valeyev 0:e056ac8fecf8 175 delta = ticker->queue->max_delta;
valeyev 0:e056ac8fecf8 176 }
valeyev 0:e056ac8fecf8 177 } else if (32768 == queue->frequency) {
valeyev 0:e056ac8fecf8 178 // Optimized for 32KHz
valeyev 0:e056ac8fecf8 179
valeyev 0:e056ac8fecf8 180 delta = (delta_us << 15) / 1000000;
valeyev 0:e056ac8fecf8 181 if (delta > ticker->queue->max_delta) {
valeyev 0:e056ac8fecf8 182 delta = ticker->queue->max_delta;
valeyev 0:e056ac8fecf8 183 }
valeyev 0:e056ac8fecf8 184 } else {
valeyev 0:e056ac8fecf8 185 // General case
valeyev 0:e056ac8fecf8 186
valeyev 0:e056ac8fecf8 187 delta = delta_us * queue->frequency / 1000000;
valeyev 0:e056ac8fecf8 188 if (delta > ticker->queue->max_delta) {
valeyev 0:e056ac8fecf8 189 delta = ticker->queue->max_delta;
valeyev 0:e056ac8fecf8 190 }
valeyev 0:e056ac8fecf8 191 }
valeyev 0:e056ac8fecf8 192 }
valeyev 0:e056ac8fecf8 193 return (queue->tick_last_read + delta) & queue->bitmask;
valeyev 0:e056ac8fecf8 194 }
valeyev 0:e056ac8fecf8 195
valeyev 0:e056ac8fecf8 196 /**
valeyev 0:e056ac8fecf8 197 * Return 1 if the tick has incremented to or past match_tick, otherwise 0.
valeyev 0:e056ac8fecf8 198 */
valeyev 0:e056ac8fecf8 199 int _ticker_match_interval_passed(timestamp_t prev_tick, timestamp_t cur_tick, timestamp_t match_tick)
valeyev 0:e056ac8fecf8 200 {
valeyev 0:e056ac8fecf8 201 if (match_tick > prev_tick) {
valeyev 0:e056ac8fecf8 202 return (cur_tick >= match_tick) || (cur_tick < prev_tick);
valeyev 0:e056ac8fecf8 203 } else {
valeyev 0:e056ac8fecf8 204 return (cur_tick < prev_tick) && (cur_tick >= match_tick);
valeyev 0:e056ac8fecf8 205 }
valeyev 0:e056ac8fecf8 206 }
valeyev 0:e056ac8fecf8 207
valeyev 0:e056ac8fecf8 208 /**
valeyev 0:e056ac8fecf8 209 * Compute the time when the interrupt has to be triggered and schedule it.
valeyev 0:e056ac8fecf8 210 *
valeyev 0:e056ac8fecf8 211 * If there is no event in the queue or the next event to execute is in more
valeyev 0:e056ac8fecf8 212 * than ticker.queue.max_delta ticks from now then the ticker irq will be
valeyev 0:e056ac8fecf8 213 * scheduled in ticker.queue.max_delta ticks. Otherwise the irq will be
valeyev 0:e056ac8fecf8 214 * scheduled to happen when the running counter reach the timestamp of the
valeyev 0:e056ac8fecf8 215 * first event in the queue.
valeyev 0:e056ac8fecf8 216 *
valeyev 0:e056ac8fecf8 217 * @note If there is no event in the queue then the interrupt is scheduled to
valeyev 0:e056ac8fecf8 218 * in ticker.queue.max_delta. This is necessary to keep track
valeyev 0:e056ac8fecf8 219 * of the timer overflow.
valeyev 0:e056ac8fecf8 220 */
valeyev 0:e056ac8fecf8 221 static void schedule_interrupt(const ticker_data_t *const ticker)
valeyev 0:e056ac8fecf8 222 {
valeyev 0:e056ac8fecf8 223 ticker_event_queue_t *queue = ticker->queue;
valeyev 0:e056ac8fecf8 224 update_present_time(ticker);
valeyev 0:e056ac8fecf8 225
valeyev 0:e056ac8fecf8 226 if (ticker->queue->head) {
valeyev 0:e056ac8fecf8 227 us_timestamp_t present = ticker->queue->present_time;
valeyev 0:e056ac8fecf8 228 us_timestamp_t match_time = ticker->queue->head->timestamp;
valeyev 0:e056ac8fecf8 229
valeyev 0:e056ac8fecf8 230 // if the event at the head of the queue is in the past then schedule
valeyev 0:e056ac8fecf8 231 // it immediately.
valeyev 0:e056ac8fecf8 232 if (match_time <= present) {
valeyev 0:e056ac8fecf8 233 ticker->interface->fire_interrupt();
valeyev 0:e056ac8fecf8 234 return;
valeyev 0:e056ac8fecf8 235 }
valeyev 0:e056ac8fecf8 236
valeyev 0:e056ac8fecf8 237 timestamp_t match_tick = compute_tick(ticker, match_time);
valeyev 0:e056ac8fecf8 238 // The time has been checked to be future, but it could still round
valeyev 0:e056ac8fecf8 239 // to the last tick as a result of us to ticks conversion
valeyev 0:e056ac8fecf8 240 if (match_tick == queue->tick_last_read) {
valeyev 0:e056ac8fecf8 241 // Match time has already expired so fire immediately
valeyev 0:e056ac8fecf8 242 ticker->interface->fire_interrupt();
valeyev 0:e056ac8fecf8 243 return;
valeyev 0:e056ac8fecf8 244 }
valeyev 0:e056ac8fecf8 245
valeyev 0:e056ac8fecf8 246 ticker->interface->set_interrupt(match_tick);
valeyev 0:e056ac8fecf8 247 timestamp_t cur_tick = ticker->interface->read();
valeyev 0:e056ac8fecf8 248
valeyev 0:e056ac8fecf8 249 if (_ticker_match_interval_passed(queue->tick_last_read, cur_tick, match_tick)) {
valeyev 0:e056ac8fecf8 250 ticker->interface->fire_interrupt();
valeyev 0:e056ac8fecf8 251 }
valeyev 0:e056ac8fecf8 252 } else {
valeyev 0:e056ac8fecf8 253 uint32_t match_tick =
valeyev 0:e056ac8fecf8 254 (queue->tick_last_read + queue->max_delta) & queue->bitmask;
valeyev 0:e056ac8fecf8 255 ticker->interface->set_interrupt(match_tick);
valeyev 0:e056ac8fecf8 256 }
valeyev 0:e056ac8fecf8 257 }
valeyev 0:e056ac8fecf8 258
valeyev 0:e056ac8fecf8 259 void ticker_set_handler(const ticker_data_t *const ticker, ticker_event_handler handler)
valeyev 0:e056ac8fecf8 260 {
valeyev 0:e056ac8fecf8 261 initialize(ticker);
valeyev 0:e056ac8fecf8 262
valeyev 0:e056ac8fecf8 263 core_util_critical_section_enter();
valeyev 0:e056ac8fecf8 264 set_handler(ticker, handler);
valeyev 0:e056ac8fecf8 265 core_util_critical_section_exit();
valeyev 0:e056ac8fecf8 266 }
valeyev 0:e056ac8fecf8 267
valeyev 0:e056ac8fecf8 268 void ticker_irq_handler(const ticker_data_t *const ticker)
valeyev 0:e056ac8fecf8 269 {
valeyev 0:e056ac8fecf8 270 core_util_critical_section_enter();
valeyev 0:e056ac8fecf8 271
valeyev 0:e056ac8fecf8 272 ticker->interface->clear_interrupt();
valeyev 0:e056ac8fecf8 273
valeyev 0:e056ac8fecf8 274 /* Go through all the pending TimerEvents */
valeyev 0:e056ac8fecf8 275 while (1) {
valeyev 0:e056ac8fecf8 276 if (ticker->queue->head == NULL) {
valeyev 0:e056ac8fecf8 277 break;
valeyev 0:e056ac8fecf8 278 }
valeyev 0:e056ac8fecf8 279
valeyev 0:e056ac8fecf8 280 // update the current timestamp used by the queue
valeyev 0:e056ac8fecf8 281 update_present_time(ticker);
valeyev 0:e056ac8fecf8 282
valeyev 0:e056ac8fecf8 283 if (ticker->queue->head->timestamp <= ticker->queue->present_time) {
valeyev 0:e056ac8fecf8 284 // This event was in the past:
valeyev 0:e056ac8fecf8 285 // point to the following one and execute its handler
valeyev 0:e056ac8fecf8 286 ticker_event_t *p = ticker->queue->head;
valeyev 0:e056ac8fecf8 287 ticker->queue->head = ticker->queue->head->next;
valeyev 0:e056ac8fecf8 288 if (ticker->queue->event_handler != NULL) {
valeyev 0:e056ac8fecf8 289 (*ticker->queue->event_handler)(p->id); // NOTE: the handler can set new events
valeyev 0:e056ac8fecf8 290 }
valeyev 0:e056ac8fecf8 291 /* Note: We continue back to examining the head because calling the
valeyev 0:e056ac8fecf8 292 * event handler may have altered the chain of pending events. */
valeyev 0:e056ac8fecf8 293 } else {
valeyev 0:e056ac8fecf8 294 break;
valeyev 0:e056ac8fecf8 295 }
valeyev 0:e056ac8fecf8 296 }
valeyev 0:e056ac8fecf8 297
valeyev 0:e056ac8fecf8 298 schedule_interrupt(ticker);
valeyev 0:e056ac8fecf8 299
valeyev 0:e056ac8fecf8 300 core_util_critical_section_exit();
valeyev 0:e056ac8fecf8 301 }
valeyev 0:e056ac8fecf8 302
valeyev 0:e056ac8fecf8 303 void ticker_insert_event(const ticker_data_t *const ticker, ticker_event_t *obj, timestamp_t timestamp, uint32_t id)
valeyev 0:e056ac8fecf8 304 {
valeyev 0:e056ac8fecf8 305 core_util_critical_section_enter();
valeyev 0:e056ac8fecf8 306
valeyev 0:e056ac8fecf8 307 // update the current timestamp
valeyev 0:e056ac8fecf8 308 update_present_time(ticker);
valeyev 0:e056ac8fecf8 309 us_timestamp_t absolute_timestamp = convert_timestamp(
valeyev 0:e056ac8fecf8 310 ticker->queue->present_time,
valeyev 0:e056ac8fecf8 311 timestamp
valeyev 0:e056ac8fecf8 312 );
valeyev 0:e056ac8fecf8 313
valeyev 0:e056ac8fecf8 314 // defer to ticker_insert_event_us
valeyev 0:e056ac8fecf8 315 ticker_insert_event_us(
valeyev 0:e056ac8fecf8 316 ticker,
valeyev 0:e056ac8fecf8 317 obj, absolute_timestamp, id
valeyev 0:e056ac8fecf8 318 );
valeyev 0:e056ac8fecf8 319
valeyev 0:e056ac8fecf8 320 core_util_critical_section_exit();
valeyev 0:e056ac8fecf8 321 }
valeyev 0:e056ac8fecf8 322
valeyev 0:e056ac8fecf8 323 void ticker_insert_event_us(const ticker_data_t *const ticker, ticker_event_t *obj, us_timestamp_t timestamp, uint32_t id)
valeyev 0:e056ac8fecf8 324 {
valeyev 0:e056ac8fecf8 325 core_util_critical_section_enter();
valeyev 0:e056ac8fecf8 326
valeyev 0:e056ac8fecf8 327 // update the current timestamp
valeyev 0:e056ac8fecf8 328 update_present_time(ticker);
valeyev 0:e056ac8fecf8 329
valeyev 0:e056ac8fecf8 330 // initialise our data
valeyev 0:e056ac8fecf8 331 obj->timestamp = timestamp;
valeyev 0:e056ac8fecf8 332 obj->id = id;
valeyev 0:e056ac8fecf8 333
valeyev 0:e056ac8fecf8 334 /* Go through the list until we either reach the end, or find
valeyev 0:e056ac8fecf8 335 an element this should come before (which is possibly the
valeyev 0:e056ac8fecf8 336 head). */
valeyev 0:e056ac8fecf8 337 ticker_event_t *prev = NULL, *p = ticker->queue->head;
valeyev 0:e056ac8fecf8 338 while (p != NULL) {
valeyev 0:e056ac8fecf8 339 /* check if we come before p */
valeyev 0:e056ac8fecf8 340 if (timestamp < p->timestamp) {
valeyev 0:e056ac8fecf8 341 break;
valeyev 0:e056ac8fecf8 342 }
valeyev 0:e056ac8fecf8 343 /* go to the next element */
valeyev 0:e056ac8fecf8 344 prev = p;
valeyev 0:e056ac8fecf8 345 p = p->next;
valeyev 0:e056ac8fecf8 346 }
valeyev 0:e056ac8fecf8 347
valeyev 0:e056ac8fecf8 348 /* if we're at the end p will be NULL, which is correct */
valeyev 0:e056ac8fecf8 349 obj->next = p;
valeyev 0:e056ac8fecf8 350
valeyev 0:e056ac8fecf8 351 /* if prev is NULL we're at the head */
valeyev 0:e056ac8fecf8 352 if (prev == NULL) {
valeyev 0:e056ac8fecf8 353 ticker->queue->head = obj;
valeyev 0:e056ac8fecf8 354 } else {
valeyev 0:e056ac8fecf8 355 prev->next = obj;
valeyev 0:e056ac8fecf8 356 }
valeyev 0:e056ac8fecf8 357
valeyev 0:e056ac8fecf8 358 schedule_interrupt(ticker);
valeyev 0:e056ac8fecf8 359
valeyev 0:e056ac8fecf8 360 core_util_critical_section_exit();
valeyev 0:e056ac8fecf8 361
valeyev 0:e056ac8fecf8 362 }
valeyev 0:e056ac8fecf8 363
valeyev 0:e056ac8fecf8 364 void ticker_remove_event(const ticker_data_t *const ticker, ticker_event_t *obj)
valeyev 0:e056ac8fecf8 365 {
valeyev 0:e056ac8fecf8 366 core_util_critical_section_enter();
valeyev 0:e056ac8fecf8 367
valeyev 0:e056ac8fecf8 368 // remove this object from the list
valeyev 0:e056ac8fecf8 369 if (ticker->queue->head == obj) {
valeyev 0:e056ac8fecf8 370 // first in the list, so just drop me
valeyev 0:e056ac8fecf8 371 ticker->queue->head = obj->next;
valeyev 0:e056ac8fecf8 372 schedule_interrupt(ticker);
valeyev 0:e056ac8fecf8 373 } else {
valeyev 0:e056ac8fecf8 374 // find the object before me, then drop me
valeyev 0:e056ac8fecf8 375 ticker_event_t* p = ticker->queue->head;
valeyev 0:e056ac8fecf8 376 while (p != NULL) {
valeyev 0:e056ac8fecf8 377 if (p->next == obj) {
valeyev 0:e056ac8fecf8 378 p->next = obj->next;
valeyev 0:e056ac8fecf8 379 break;
valeyev 0:e056ac8fecf8 380 }
valeyev 0:e056ac8fecf8 381 p = p->next;
valeyev 0:e056ac8fecf8 382 }
valeyev 0:e056ac8fecf8 383 }
valeyev 0:e056ac8fecf8 384
valeyev 0:e056ac8fecf8 385 core_util_critical_section_exit();
valeyev 0:e056ac8fecf8 386 }
valeyev 0:e056ac8fecf8 387
valeyev 0:e056ac8fecf8 388 timestamp_t ticker_read(const ticker_data_t *const ticker)
valeyev 0:e056ac8fecf8 389 {
valeyev 0:e056ac8fecf8 390 return ticker_read_us(ticker);
valeyev 0:e056ac8fecf8 391 }
valeyev 0:e056ac8fecf8 392
valeyev 0:e056ac8fecf8 393 us_timestamp_t ticker_read_us(const ticker_data_t *const ticker)
valeyev 0:e056ac8fecf8 394 {
valeyev 0:e056ac8fecf8 395 initialize(ticker);
valeyev 0:e056ac8fecf8 396
valeyev 0:e056ac8fecf8 397 core_util_critical_section_enter();
valeyev 0:e056ac8fecf8 398 update_present_time(ticker);
valeyev 0:e056ac8fecf8 399 core_util_critical_section_exit();
valeyev 0:e056ac8fecf8 400
valeyev 0:e056ac8fecf8 401 return ticker->queue->present_time;
valeyev 0:e056ac8fecf8 402 }
valeyev 0:e056ac8fecf8 403
valeyev 0:e056ac8fecf8 404 int ticker_get_next_timestamp(const ticker_data_t *const data, timestamp_t *timestamp)
valeyev 0:e056ac8fecf8 405 {
valeyev 0:e056ac8fecf8 406 int ret = 0;
valeyev 0:e056ac8fecf8 407
valeyev 0:e056ac8fecf8 408 /* if head is NULL, there are no pending events */
valeyev 0:e056ac8fecf8 409 core_util_critical_section_enter();
valeyev 0:e056ac8fecf8 410 if (data->queue->head != NULL) {
valeyev 0:e056ac8fecf8 411 *timestamp = data->queue->head->timestamp;
valeyev 0:e056ac8fecf8 412 ret = 1;
valeyev 0:e056ac8fecf8 413 }
valeyev 0:e056ac8fecf8 414 core_util_critical_section_exit();
valeyev 0:e056ac8fecf8 415
valeyev 0:e056ac8fecf8 416 return ret;
valeyev 0:e056ac8fecf8 417 }