Keil Studio Cloud
Mistake on this page?
Report an issue in GitHub or email us
LowPowerTickerWrapper.h
1 
2 /** \addtogroup hal */
3 /** @{*/
4 /* mbed Microcontroller Library
5  * Copyright (c) 2018 ARM Limited
6  * SPDX-License-Identifier: Apache-2.0
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  */
20 #ifndef MBED_LOW_POWER_TICKER_WRAPPER_H
21 #define MBED_LOW_POWER_TICKER_WRAPPER_H
22 
23 #include "device.h"
24 
25 #include "hal/ticker_api.h"
26 #include "hal/us_ticker_api.h"
27 #include "drivers/Timeout.h"
28 
29 
30 class LowPowerTickerWrapper {
31 public:
32 
33 
34  /**
35  * Create a new wrapped low power ticker object
36  *
37  * @param data Low power ticker data to wrap
38  * @param interface new ticker interface functions
39  * @param min_cycles_between_writes The number of whole low power clock periods
40  * which must complete before subsequent calls to set_interrupt
41  * @param min_cycles_until_match The minimum number of whole low power clock periods
42  * from the current time for which the match timestamp passed to set_interrupt is
43  * guaranteed to fire.
44  *
45  * N = min_cycles_between_writes
46  *
47  * 0 1 N - 1 N N + 1 N + 2 N + 3
48  * |-------|------...------|-------|-------|-------|-------|
49  * ^ ^
50  * | |
51  * set_interrupt Next set_interrupt allowed
52  *
53  * N = min_cycles_until_match
54  *
55  * 0 1 N - 1 N N + 1 N + 2 N + 3
56  * |-------|------...------|-------|-------|-------|-------|
57  * ^ ^
58  * | |
59  * set_interrupt Earliest match timestamp allowed
60  *
61  *
62  */
63 
64  LowPowerTickerWrapper(const ticker_data_t *data, const ticker_interface_t *interface, uint32_t min_cycles_between_writes, uint32_t min_cycles_until_match);
65 
66  /**
67  * Interrupt handler called by the underlying driver/hardware
68  *
69  * @param handler The callback which would normally be called by the underlying driver/hardware
70  */
71  void irq_handler(ticker_irq_handler_type handler);
72 
73  /**
74  * Suspend wrapper operation and pass through interrupts.
75  *
76  * This stops to wrapper layer from using the microsecond ticker.
77  * This should be called before using the low power ticker APIs directly.
78  *
79  * @warning: Make sure to suspend the LP ticker first (call ticker_suspend()),
80  * otherwise the behavior is undefined.
81  */
82  void suspend();
83 
84  /**
85  * Resume wrapper operation and filter interrupts normally
86  */
87  void resume();
88 
89  /**
90  * Check if a Timeout object is being used
91  *
92  * @return true if Timeout is used for scheduling false otherwise
93  */
94  bool timeout_pending();
95 
96  /*
97  * Implementation of ticker_init
98  */
99  void init();
100 
101  /*
102  * Implementation of free
103  */
104  void free();
105 
106  /*
107  * Implementation of read
108  */
109  uint32_t read();
110 
111  /*
112  * Implementation of set_interrupt
113  */
114  void set_interrupt(timestamp_t timestamp);
115 
116  /*
117  * Implementation of disable_interrupt
118  */
119  void disable_interrupt();
120 
121  /*
122  * Implementation of clear_interrupt
123  */
124  void clear_interrupt();
125 
126  /*
127  * Implementation of fire_interrupt
128  */
129  void fire_interrupt();
130 
131  /*
132  * Implementation of get_info
133  */
134  const ticker_info_t *get_info();
135 
136  ticker_data_t data;
137 
138 private:
139  mbed::Timeout _timeout;
140  const ticker_interface_t *const _intf;
141 
142  /*
143  * The number of low power clock cycles which must pass between subsequent
144  * calls to intf->set_interrupt
145  */
146  const uint32_t _min_count_between_writes;
147 
148  /*
149  * The minimum number of low power clock cycles in the future that
150  * a match value can be set to and still fire
151  */
152  const uint32_t _min_count_until_match;
153 
154  /*
155  * Flag to indicate if the timer is suspended
156  */
157  bool _suspended;
158 
159  /*
160  * _cur_match_time is valid and Timeout is scheduled to fire
161  */
162  bool _pending_timeout;
163 
164  /*
165  * set_interrupt has been called and _cur_match_time is valid
166  */
167  bool _pending_match;
168 
169  /*
170  * The function LowPowerTickerWrapper::fire_interrupt has been called
171  * and an interrupt is expected.
172  */
173  bool _pending_fire_now;
174 
175  /*
176  * It is safe to call intf->set_interrupt
177  */
178  bool _set_interrupt_allowed;
179 
180  /*
181  * Last value written by LowPowerTickerWrapper::set_interrupt
182  */
183  timestamp_t _cur_match_time;
184 
185  /*
186  * Time of last call to LowPowerTickerWrapper::set_interrupt
187  */
188  uint32_t _last_set_interrupt;
189 
190  /*
191  * Time of last call to intf->set_interrupt
192  */
193  uint32_t _last_actual_set_interrupt;
194 
195  /*
196  * Mask of valid bits from intf->read()
197  */
198  uint32_t _mask;
199 
200  /*
201  * Microsecond per low power tick (rounded up)
202  */
203  uint32_t _us_per_tick;
204 
205 
206  void _reset();
207 
208  /**
209  * Set the low power ticker match time when hardware is ready
210  *
211  * This event is scheduled to set the lp timer after the previous write
212  * has taken effect and it is safe to write a new value without blocking.
213  * If the time has already passed then this function fires and interrupt
214  * immediately.
215  */
216  void _timeout_handler();
217 
218  /*
219  * Check match time has passed
220  */
221  bool _match_check(timestamp_t current);
222 
223  /*
224  * Convert low power ticks to approximate microseconds
225  *
226  * This value is always larger or equal to exact value.
227  */
228  uint32_t _lp_ticks_to_us(uint32_t);
229 
230  /*
231  * Schedule a match interrupt to fire at the correct time
232  *
233  * @param current The current low power ticker time
234  */
235  void _schedule_match(timestamp_t current);
236 
237 };
238 
239 #endif
240 
241 /** @}*/
242 
243 
LowPowerTickerWrapper::irq_handler
void irq_handler(ticker_irq_handler_type handler)
Interrupt handler called by the underlying driver/hardware.
ticker_info_t
Information about the ticker implementation.
Definition: ticker_api.h:53
ticker_interface_t
Ticker's interface structure - required API for a ticker.
Definition: ticker_api.h:61
ticker_data_t
Ticker's data structure.
Definition: ticker_api.h:93
LowPowerTickerWrapper::LowPowerTickerWrapper
LowPowerTickerWrapper(const ticker_data_t *data, const ticker_interface_t *interface, uint32_t min_cycles_between_writes, uint32_t min_cycles_until_match)
Create a new wrapped low power ticker object.
LowPowerTickerWrapper::suspend
void suspend()
Suspend wrapper operation and pass through interrupts.
timestamp_t
uint32_t timestamp_t
Legacy format representing a timestamp in us.
Definition: ticker_api.h:33
LowPowerTickerWrapper::resume
void resume()
Resume wrapper operation and filter interrupts normally.
mbed::Timeout
A Timeout is used to call a function at a point in the future.
Definition: Timeout.h:58
LowPowerTickerWrapper::timeout_pending
bool timeout_pending()
Check if a Timeout object is being used.
Important Information for this Arm website

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling cookies, some features of the site will not work.