BA / SerialCom

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 OmniWheels by Gustav Atmel

mbed-os/hal/mbed_ticker_api.c@2:798925c9e4a8, 2018-05-01 (annotated)

Committer:
gustavatmel
Date:
Tue May 01 15:55:34 2018 +0000
Revision:
2:798925c9e4a8
Parent:
1:9c5af431a1f1 
bluetooth

Who changed what in which revision?

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