1 /* mbed Microcontroller Library
2 * Copyright (c) 2013 Nordic Semiconductor
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "us_ticker_api.h"
20 #include "PeripheralNames.h"
21 #include "nrf_delay.h"
24 * Note: The micro-second timer API on the nRF51 platform is implemented using
25 * the RTC counter run at 32kHz (sourced from an external oscillator). This is
26 * a trade-off between precision and power. Running a normal 32-bit MCU counter
27 * at high frequency causes the average power consumption to rise to a few
28 * hundred micro-amps, which is prohibitive for typical low-power BLE
30 * A 32kHz clock doesn't offer the precision needed for keeping u-second time,
31 * but we're assuming that this will not be a problem for the average user.
34 #define MAX_RTC_COUNTER_VAL 0x00FFFFFF /**< Maximum value of the RTC counter. */
35 #define RTC_CLOCK_FREQ (uint32_t)(32768)
36 #define RTC1_IRQ_PRI 3 /**< Priority of the RTC1 interrupt (used
37 * for checking for timeouts and executing
38 * timeout handlers). This must be the same
39 * as APP_IRQ_PRIORITY_LOW; taken from the
41 #define MAX_RTC_TASKS_DELAY 47 /**< Maximum delay until an RTC task is executed. */
43 #define FUZZY_RTC_TICKS 2 /* RTC COMPARE occurs when a CC register is N and the RTC
44 * COUNTER value transitions from N-1 to N. If we're trying to
45 * setup a callback for a time which will arrive very shortly,
46 * there are limits to how short the callback interval may be for us
47 * to rely upon the RTC Compare trigger. If the COUNTER is N,
48 * writing N+2 to a CC register is guaranteed to trigger a COMPARE
51 #define RTC_UNITS_TO_MICROSECONDS(RTC_UNITS) (((RTC_UNITS) * (uint64_t)1000000) / RTC_CLOCK_FREQ)
52 #define MICROSECONDS_TO_RTC_UNITS(MICROS) ((((uint64_t)(MICROS) * RTC_CLOCK_FREQ) + 999999) / 1000000)
54 static bool us_ticker_inited = false;
55 static volatile uint32_t overflowCount; /**< The number of times the 24-bit RTC counter has overflowed. */
56 static volatile bool us_ticker_callbackPending = false;
57 static uint32_t us_ticker_callbackTimestamp;
59 static inline void rtc1_enableCompareInterrupt(void)
61 NRF_RTC1->EVTENCLR = RTC_EVTEN_COMPARE0_Msk;
62 NRF_RTC1->INTENSET = RTC_INTENSET_COMPARE0_Msk;
65 static inline void rtc1_disableCompareInterrupt(void)
67 NRF_RTC1->INTENCLR = RTC_INTENSET_COMPARE0_Msk;
68 NRF_RTC1->EVTENCLR = RTC_EVTEN_COMPARE0_Msk;
71 static inline void rtc1_enableOverflowInterrupt(void)
73 NRF_RTC1->EVTENCLR = RTC_EVTEN_OVRFLW_Msk;
74 NRF_RTC1->INTENSET = RTC_INTENSET_OVRFLW_Msk;
77 static inline void rtc1_disableOverflowInterrupt(void)
79 NRF_RTC1->INTENCLR = RTC_INTENSET_OVRFLW_Msk;
80 NRF_RTC1->EVTENCLR = RTC_EVTEN_OVRFLW_Msk;
83 static inline void invokeCallback(void)
85 us_ticker_callbackPending = false;
86 rtc1_disableCompareInterrupt();
87 us_ticker_irq_handler();
91 * @brief Function for starting the RTC1 timer. The RTC timer is expected to
92 * keep running--some interrupts may be disabled temporarily.
94 static void rtc1_start()
96 NRF_RTC1->PRESCALER = 0; /* for no pre-scaling. */
98 rtc1_enableOverflowInterrupt();
100 NVIC_SetPriority(RTC1_IRQn, RTC1_IRQ_PRI);
101 NVIC_ClearPendingIRQ(RTC1_IRQn);
102 NVIC_EnableIRQ(RTC1_IRQn);
104 NRF_RTC1->TASKS_START = 1;
105 nrf_delay_us(MAX_RTC_TASKS_DELAY);
109 * @brief Function for stopping the RTC1 timer. We don't expect to call this.
113 NVIC_DisableIRQ(RTC1_IRQn);
114 rtc1_disableCompareInterrupt();
115 rtc1_disableOverflowInterrupt();
117 NRF_RTC1->TASKS_STOP = 1;
118 nrf_delay_us(MAX_RTC_TASKS_DELAY);
120 NRF_RTC1->TASKS_CLEAR = 1;
121 nrf_delay_us(MAX_RTC_TASKS_DELAY);
125 * @brief Function for returning the current value of the RTC1 counter.
127 * @return Current RTC1 counter as a 64-bit value with 56-bit precision (even
128 * though the underlying counter is 24-bit)
130 static inline uint64_t rtc1_getCounter64(void)
132 if (NRF_RTC1->EVENTS_OVRFLW) {
134 NRF_RTC1->EVENTS_OVRFLW = 0;
135 NRF_RTC1->EVTENCLR = RTC_EVTEN_OVRFLW_Msk;
137 return ((uint64_t)overflowCount << 24) | NRF_RTC1->COUNTER;
141 * @brief Function for returning the current value of the RTC1 counter.
143 * @return Current RTC1 counter as a 32-bit value (even though the underlying counter is 24-bit)
145 static inline uint32_t rtc1_getCounter(void)
147 return rtc1_getCounter64();
151 * @brief Function for handling the RTC1 interrupt.
153 * @details Checks for timeouts, and executes timeout handlers for expired timers.
155 void RTC1_IRQHandler(void)
157 if (NRF_RTC1->EVENTS_OVRFLW) {
159 NRF_RTC1->EVENTS_OVRFLW = 0;
160 NRF_RTC1->EVTENCLR = RTC_EVTEN_OVRFLW_Msk;
162 if (NRF_RTC1->EVENTS_COMPARE[0] && us_ticker_callbackPending && ((int)(us_ticker_callbackTimestamp - rtc1_getCounter()) <= 0)) {
163 NRF_RTC1->EVENTS_COMPARE[0] = 0;
164 NRF_RTC1->EVTENCLR = RTC_EVTEN_COMPARE0_Msk;
169 void us_ticker_init(void)
171 if (us_ticker_inited) {
176 us_ticker_inited = true;
179 uint32_t us_ticker_read()
181 if (!us_ticker_inited) {
185 /* Return a pseudo microsecond counter value. This is only as precise as the
186 * 32khz low-freq clock source, but could be adequate.*/
187 return RTC_UNITS_TO_MICROSECONDS(rtc1_getCounter64());
191 * Setup the us_ticker callback interrupt to go at the given timestamp.
193 * @Note: Only one callback is pending at any time.
195 * @Note: If a callback is pending, and this function is called again, the new
196 * callback-time overrides the existing callback setting. It is the caller's
197 * responsibility to ensure that this function is called to setup a callback for
198 * the earliest timeout.
200 * @Note: If this function is used to setup an interrupt which is immediately
201 * pending--such as for 'now' or a time in the past,--then the callback is
202 * invoked a few ticks later.
204 void us_ticker_set_interrupt(timestamp_t timestamp)
206 if (!us_ticker_inited) {
211 * The argument to this function is a 32-bit microsecond timestamp for when
212 * a callback should be invoked. On the nRF51, we use an RTC timer running
213 * at 32kHz to implement a low-power us-ticker. This results in a problem
214 * based on the fact that 1000000 is not a multiple of 32768.
216 * Going from a micro-second based timestamp to a 32kHz based RTC-time is a
217 * linear mapping; but this mapping doesn't preserve wraparounds--i.e. when
218 * the 32-bit micro-second timestamp wraps around unfortunately the
219 * underlying RTC counter doesn't. The result is that timestamp expiry
220 * checks on micro-second timestamps don't yield the same result when
221 * applied on the corresponding RTC timestamp values.
223 * One solution is to translate the incoming 32-bit timestamp into a virtual
224 * 64-bit timestamp based on the knowledge of system-uptime, and then use
225 * this wraparound-free 64-bit value to do a linear mapping to RTC time.
226 * System uptime on an nRF is maintained using the 24-bit RTC counter. We
227 * track the overflow count to extend the 24-bit hardware counter by an
228 * additional 32 bits. RTC_UNITS_TO_MICROSECONDS() converts this into
229 * microsecond units (in 64-bits).
231 const uint64_t currentTime64 = RTC_UNITS_TO_MICROSECONDS(rtc1_getCounter64());
232 uint64_t timestamp64 = (currentTime64 & ~(uint64_t)0xFFFFFFFFULL) + timestamp;
233 if (((uint32_t)currentTime64 > 0x80000000) && (timestamp < 0x80000000)) {
234 timestamp64 += (uint64_t)0x100000000ULL;
236 uint32_t newCallbackTime = MICROSECONDS_TO_RTC_UNITS(timestamp64);
238 /* Check for repeat setup of an existing callback. This is actually not
239 * important; the following code should work even without this check. */
240 if (us_ticker_callbackPending && (newCallbackTime == us_ticker_callbackTimestamp)) {
244 /* Check for callbacks which are immediately (or will *very* shortly become) pending.
245 * Even if they are immediately pending, they are scheduled to trigger a few
246 * ticks later. This keeps things simple by invoking the callback from an
247 * independent interrupt context. */
248 if ((int)(newCallbackTime - rtc1_getCounter()) <= (int)FUZZY_RTC_TICKS) {
249 newCallbackTime = rtc1_getCounter() + FUZZY_RTC_TICKS;
252 NRF_RTC1->CC[0] = newCallbackTime & MAX_RTC_COUNTER_VAL;
253 us_ticker_callbackTimestamp = newCallbackTime;
254 if (!us_ticker_callbackPending) {
255 us_ticker_callbackPending = true;
256 rtc1_enableCompareInterrupt();
260 void us_ticker_disable_interrupt(void)
262 if (us_ticker_callbackPending) {
263 rtc1_disableCompareInterrupt();
264 us_ticker_callbackPending = false;
268 void us_ticker_clear_interrupt(void)
270 NRF_RTC1->EVENTS_OVRFLW = 0;
271 NRF_RTC1->EVENTS_COMPARE[0] = 0;