marcus chiou / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/hal/TARGET_Atmel/TARGET_SAM21/drivers/tc/tc.h@592:a274ee790e56, 2015-07-17 (annotated)

Committer:
mbed_official
Date:
Fri Jul 17 09:15:10 2015 +0100
Revision:
592:a274ee790e56
Parent:
579:53297373a894 
Synchronized with git revision e7144f83a8d75df80c4877936b6ffe552b0be9e6



Full URL: https://github.com/mbedmicro/mbed/commit/e7144f83a8d75df80c4877936b6ffe552b0be9e6/



More API implementation for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 579:53297373a894 1 #ifndef TC_H_INCLUDED
mbed_official 579:53297373a894 2 #define TC_H_INCLUDED
mbed_official 579:53297373a894 3
mbed_official 579:53297373a894 4 /**
mbed_official 579:53297373a894 5 * \defgroup asfdoc_sam0_tc_group SAM Timer/Counter Driver (TC)
mbed_official 579:53297373a894 6 *
mbed_official 579:53297373a894 7 * This driver for Atmel庐 | SMART SAM devices provides an interface for the configuration
mbed_official 579:53297373a894 8 * and management of the timer modules within the device, for waveform
mbed_official 579:53297373a894 9 * generation and timing operations. The following driver API modes are covered
mbed_official 579:53297373a894 10 * by this manual:
mbed_official 579:53297373a894 11 *
mbed_official 579:53297373a894 12 * - Polled APIs
mbed_official 579:53297373a894 13 * \if TC_CALLBACK_MODE
mbed_official 579:53297373a894 14 * - Callback APIs
mbed_official 579:53297373a894 15 * \endif
mbed_official 579:53297373a894 16 *
mbed_official 579:53297373a894 17 *
mbed_official 579:53297373a894 18 * The following peripherals are used by this module:
mbed_official 579:53297373a894 19 * - TC (Timer/Counter)
mbed_official 579:53297373a894 20 *
mbed_official 579:53297373a894 21 * The following devices can use this module:
mbed_official 579:53297373a894 22 * - Atmel | SMART SAM D20/D21
mbed_official 579:53297373a894 23 * - Atmel | SMART SAM R21
mbed_official 579:53297373a894 24 * - Atmel | SMART SAM D10/D11
mbed_official 579:53297373a894 25 * - Atmel | SMART SAM L21
mbed_official 579:53297373a894 26 *
mbed_official 579:53297373a894 27 * The outline of this documentation is as follows:
mbed_official 579:53297373a894 28 * - \ref asfdoc_sam0_tc_prerequisites
mbed_official 579:53297373a894 29 * - \ref asfdoc_sam0_tc_module_overview
mbed_official 579:53297373a894 30 * - \ref asfdoc_sam0_tc_special_considerations
mbed_official 579:53297373a894 31 * - \ref asfdoc_sam0_tc_extra_info
mbed_official 579:53297373a894 32 * - \ref asfdoc_sam0_tc_examples
mbed_official 579:53297373a894 33 * - \ref asfdoc_sam0_tc_api_overview
mbed_official 579:53297373a894 34 *
mbed_official 579:53297373a894 35 *
mbed_official 579:53297373a894 36 * \section asfdoc_sam0_tc_prerequisites Prerequisites
mbed_official 579:53297373a894 37 *
mbed_official 579:53297373a894 38 * There are no prerequisites for this module.
mbed_official 579:53297373a894 39 *
mbed_official 579:53297373a894 40 *
mbed_official 579:53297373a894 41 * \section asfdoc_sam0_tc_module_overview Module Overview
mbed_official 579:53297373a894 42 *
mbed_official 579:53297373a894 43 * The Timer/Counter (TC) module provides a set of timing and counting related
mbed_official 579:53297373a894 44 * functionality, such as the generation of periodic waveforms, the capturing
mbed_official 579:53297373a894 45 * of a periodic waveform's frequency/duty cycle, and software timekeeping for
mbed_official 579:53297373a894 46 * periodic operations. TC modules can be configured to use an 8-, 16-, or
mbed_official 579:53297373a894 47 * 32-bit counter size.
mbed_official 579:53297373a894 48 *
mbed_official 579:53297373a894 49 * This TC module for the SAM is capable of the following functions:
mbed_official 579:53297373a894 50 *
mbed_official 579:53297373a894 51 * - Generation of PWM signals
mbed_official 579:53297373a894 52 * - Generation of timestamps for events
mbed_official 579:53297373a894 53 * - General time counting
mbed_official 579:53297373a894 54 * - Waveform period capture
mbed_official 579:53297373a894 55 * - Waveform frequency capture
mbed_official 579:53297373a894 56 *
mbed_official 579:53297373a894 57 * \ref asfdoc_sam0_tc_block_diagram "The diagram below" shows the overview
mbed_official 579:53297373a894 58 * of the TC module design.
mbed_official 579:53297373a894 59 *
mbed_official 579:53297373a894 60 * \anchor asfdoc_sam0_tc_block_diagram
mbed_official 579:53297373a894 61 * \image html overview.svg "Basic Overview of the TC Module"
mbed_official 579:53297373a894 62 *
mbed_official 579:53297373a894 63 *
mbed_official 579:53297373a894 64 * \subsection asfdoc_sam0_tc_features Driver Feature Macro Definition
mbed_official 579:53297373a894 65 * <table>
mbed_official 579:53297373a894 66 * <tr>
mbed_official 579:53297373a894 67 * <th>Driver Feature Macro</th>
mbed_official 579:53297373a894 68 * <th>Supported devices</th>
mbed_official 579:53297373a894 69 * </tr>
mbed_official 579:53297373a894 70 * <tr>
mbed_official 579:53297373a894 71 * <td>FEATURE_TC_DOUBLE_BUFFERED</td>
mbed_official 579:53297373a894 72 * <td>SAML21</td>
mbed_official 579:53297373a894 73 * </tr>
mbed_official 579:53297373a894 74 * <tr>
mbed_official 579:53297373a894 75 * <td>FEATURE_TC_SYNCBUSY_SCHEME_VERSION_2</td>
mbed_official 579:53297373a894 76 * <td>SAML21</td>
mbed_official 579:53297373a894 77 * </tr>
mbed_official 579:53297373a894 78 * <tr>
mbed_official 579:53297373a894 79 * <td>FEATURE_TC_STAMP_PW_CAPTURE</td>
mbed_official 579:53297373a894 80 * <td>SAML21</td>
mbed_official 579:53297373a894 81 * </tr>
mbed_official 579:53297373a894 82 * <tr>
mbed_official 579:53297373a894 83 * <td>FEATURE_TC_READ_SYNC</td>
mbed_official 579:53297373a894 84 * <td>SAML21</td>
mbed_official 579:53297373a894 85 * </tr>
mbed_official 579:53297373a894 86 * <tr>
mbed_official 579:53297373a894 87 * <td>FEATURE_TC_IO_CAPTURE</td>
mbed_official 579:53297373a894 88 * <td>SAML21</td>
mbed_official 579:53297373a894 89 * </tr>
mbed_official 579:53297373a894 90 * </table>
mbed_official 579:53297373a894 91 * \note The specific features are only available in the driver when the
mbed_official 579:53297373a894 92 * selected device supports those features.
mbed_official 579:53297373a894 93 *
mbed_official 579:53297373a894 94 * \subsection asfdoc_sam0_tc_module_overview_func_desc Functional Description
mbed_official 579:53297373a894 95 * Independent of the configured counter size, each TC module can be set up
mbed_official 579:53297373a894 96 * in one of two different modes; capture and compare.
mbed_official 579:53297373a894 97 *
mbed_official 579:53297373a894 98 * In capture mode, the counter value is stored when a configurable event
mbed_official 579:53297373a894 99 * occurs. This mode can be used to generate timestamps used in event capture,
mbed_official 579:53297373a894 100 * or it can be used for the measurement of a periodic input signal's
mbed_official 579:53297373a894 101 * frequency/duty cycle.
mbed_official 579:53297373a894 102 *
mbed_official 579:53297373a894 103 * In compare mode, the counter value is compared against one or more of the
mbed_official 579:53297373a894 104 * configured channel compare values. When the counter value coincides with a
mbed_official 579:53297373a894 105 * compare value an action can be taken automatically by the module, such as
mbed_official 579:53297373a894 106 * generating an output event or toggling a pin when used for frequency or PWM
mbed_official 579:53297373a894 107 * signal generation.
mbed_official 579:53297373a894 108 *
mbed_official 579:53297373a894 109 * \note The connection of events between modules requires the use of the
mbed_official 579:53297373a894 110 * \ref asfdoc_sam0_events_group "SAM Event System Driver (EVENTS)"
mbed_official 579:53297373a894 111 * to route output event of one module to the the input event of another.
mbed_official 579:53297373a894 112 * For more information on event routing, refer to the event driver
mbed_official 579:53297373a894 113 * documentation.
mbed_official 579:53297373a894 114 *
mbed_official 579:53297373a894 115 * \subsection asfdoc_sam0_tc_module_overview_tc_size Timer/Counter Size
mbed_official 579:53297373a894 116 * Each timer module can be configured in one of three different counter
mbed_official 579:53297373a894 117 * sizes; 8-, 16-, and 32-bit. The size of the counter determines the maximum
mbed_official 579:53297373a894 118 * value it can count to before an overflow occurs and the count is reset back
mbed_official 579:53297373a894 119 * to zero. \ref asfdoc_sam0_tc_count_size_vs_top "The table below" shows the
mbed_official 579:53297373a894 120 * maximum values for each of the possible counter sizes.
mbed_official 579:53297373a894 121 *
mbed_official 579:53297373a894 122 * \anchor asfdoc_sam0_tc_count_size_vs_top
mbed_official 579:53297373a894 123 * <table>
mbed_official 579:53297373a894 124 * <caption>Timer Counter Sizes and Their Maximum Count Values</caption>
mbed_official 579:53297373a894 125 * <tr>
mbed_official 579:53297373a894 126 * <th>Counter size</th>
mbed_official 579:53297373a894 127 * <th>Max. (hexadecimal)</th>
mbed_official 579:53297373a894 128 * <th>Max. (decimal)</th>
mbed_official 579:53297373a894 129 * </tr>
mbed_official 579:53297373a894 130 * <tr>
mbed_official 579:53297373a894 131 * <td>8-bit</td>
mbed_official 579:53297373a894 132 * <td>0xFF</td>
mbed_official 579:53297373a894 133 * <td>255</td>
mbed_official 579:53297373a894 134 * </tr>
mbed_official 579:53297373a894 135 * <tr>
mbed_official 579:53297373a894 136 * <td>16-bit</td>
mbed_official 579:53297373a894 137 * <td>0xFFFF</td>
mbed_official 579:53297373a894 138 * <td>65,535</td>
mbed_official 579:53297373a894 139 * </tr>
mbed_official 579:53297373a894 140 * <tr>
mbed_official 579:53297373a894 141 * <td>32-bit</td>
mbed_official 579:53297373a894 142 * <td>0xFFFFFFFF</td>
mbed_official 579:53297373a894 143 * <td>4,294,967,295</td>
mbed_official 579:53297373a894 144 * </tr>
mbed_official 579:53297373a894 145 * </table>
mbed_official 579:53297373a894 146 *
mbed_official 579:53297373a894 147 * When using the counter in 16- or 32-bit count mode, Compare Capture
mbed_official 579:53297373a894 148 * register 0 (CC0) is used to store the period value when running in PWM
mbed_official 579:53297373a894 149 * generation match mode.
mbed_official 579:53297373a894 150 *
mbed_official 579:53297373a894 151 * When using 32-bit counter size, two 16-bit counters are chained together
mbed_official 579:53297373a894 152 * in a cascade formation. Except in SAM D10/D11, Even numbered TC modules
mbed_official 579:53297373a894 153 * (e.g. TC0, TC2) can be configured as 32-bit counters. The odd numbered
mbed_official 579:53297373a894 154 * counters will act as slaves to the even numbered masters, and will not
mbed_official 579:53297373a894 155 * be reconfigurable until the master timer is disabled. The pairing of timer
mbed_official 579:53297373a894 156 * modules for 32-bit mode is shown in \ref asfdoc_sam0_tc_module_ms_pairs
mbed_official 579:53297373a894 157 * "the table below".
mbed_official 579:53297373a894 158 *
mbed_official 579:53297373a894 159 * \anchor asfdoc_sam0_tc_module_ms_pairs
mbed_official 579:53297373a894 160 * <table>
mbed_official 579:53297373a894 161 * <caption>TC Master and Slave Module Pairings</caption>
mbed_official 579:53297373a894 162 * <tr>
mbed_official 579:53297373a894 163 * <th>Master TC Module</th>
mbed_official 579:53297373a894 164 * <th>Slave TC Module</th>
mbed_official 579:53297373a894 165 * </tr>
mbed_official 579:53297373a894 166 * <tr>
mbed_official 579:53297373a894 167 * <td>TC0</td>
mbed_official 579:53297373a894 168 * <td>TC1</td>
mbed_official 579:53297373a894 169 * </tr>
mbed_official 579:53297373a894 170 * <tr>
mbed_official 579:53297373a894 171 * <td>TC2</td>
mbed_official 579:53297373a894 172 * <td>TC3</td>
mbed_official 579:53297373a894 173 * </tr>
mbed_official 579:53297373a894 174 * <tr>
mbed_official 579:53297373a894 175 * <td>...</td>
mbed_official 579:53297373a894 176 * <td>...</td>
mbed_official 579:53297373a894 177 * </tr>
mbed_official 579:53297373a894 178 * <tr>
mbed_official 579:53297373a894 179 * <td>TCn-1</td>
mbed_official 579:53297373a894 180 * <td>TCn</td>
mbed_official 579:53297373a894 181 * </tr>
mbed_official 579:53297373a894 182 * </table>
mbed_official 579:53297373a894 183 *
mbed_official 579:53297373a894 184 * In SAMD10/D11, odd numbered TC modules (e.g. TC1) can be configured as 32-bit
mbed_official 579:53297373a894 185 * counters. The even numbered(e.g. TC2) counters will act as slaves to the odd
mbed_official 579:53297373a894 186 * numbered masters.
mbed_official 579:53297373a894 187 *
mbed_official 579:53297373a894 188 * \subsection asfdoc_sam0_tc_module_overview_clock Clock Settings
mbed_official 579:53297373a894 189 *
mbed_official 579:53297373a894 190 * \subsubsection asfdoc_sam0_tc_module_overview_clock_selection Clock Selection
mbed_official 579:53297373a894 191 * Each TC peripheral is clocked asynchronously to the system clock by a GCLK
mbed_official 579:53297373a894 192 * (Generic Clock) channel. The GCLK channel connects to any of the GCLK
mbed_official 579:53297373a894 193 * generators. The GCLK generators are configured to use one of the available
mbed_official 579:53297373a894 194 * clock sources on the system such as internal oscillator, external crystals,
mbed_official 579:53297373a894 195 * etc. see the \ref asfdoc_sam0_system_clock_group "Generic Clock driver"
mbed_official 579:53297373a894 196 *for
mbed_official 579:53297373a894 197 * more information.
mbed_official 579:53297373a894 198 *
mbed_official 579:53297373a894 199 * \subsubsection asfdoc_sam0_tc_module_overview_clock_prescaler Prescaler
mbed_official 579:53297373a894 200 * Each TC module in the SAM has its own individual clock prescaler, which
mbed_official 579:53297373a894 201 * can be used to divide the input clock frequency used in the counter. This
mbed_official 579:53297373a894 202 * prescaler only scales the clock used to provide clock pulses for the counter
mbed_official 579:53297373a894 203 * to count, and does not affect the digital register interface portion of
mbed_official 579:53297373a894 204 * the module, thus the timer registers will synchronize to the raw GCLK
mbed_official 579:53297373a894 205 * frequency input to the module.
mbed_official 579:53297373a894 206 *
mbed_official 579:53297373a894 207 * As a result of this, when selecting a GCLK frequency and timer prescaler
mbed_official 579:53297373a894 208 * value the user application should consider both the timer resolution
mbed_official 579:53297373a894 209 * required and the synchronization frequency, to avoid lengthy
mbed_official 579:53297373a894 210 * synchronization times of the module if a very slow GCLK frequency is fed
mbed_official 579:53297373a894 211 * into the TC module. It is preferable to use a higher module GCLK frequency
mbed_official 579:53297373a894 212 * as the input to the timer, and prescale this down as much as possible to
mbed_official 579:53297373a894 213 * obtain a suitable counter frequency in latency-sensitive applications.
mbed_official 579:53297373a894 214 *
mbed_official 579:53297373a894 215 * \subsubsection asfdoc_sam0_tc_module_overview_clock_reloading Reloading
mbed_official 579:53297373a894 216 * Timer modules also contain a configurable reload action, used when a
mbed_official 579:53297373a894 217 * re-trigger event occurs. Examples of a re-trigger event are the counter
mbed_official 579:53297373a894 218 * reaching the maximum value when counting up, or when an event from the event
mbed_official 579:53297373a894 219 * system tells the counter to re-trigger. The reload action determines if the
mbed_official 579:53297373a894 220 * prescaler should be reset, and when this should happen. The counter will
mbed_official 579:53297373a894 221 * always be reloaded with the value it is set to start counting from. The user
mbed_official 579:53297373a894 222 * can choose between three different reload actions, described in
mbed_official 579:53297373a894 223 * \ref asfdoc_sam0_tc_module_reload_act "the table below".
mbed_official 579:53297373a894 224 *
mbed_official 579:53297373a894 225 * \anchor asfdoc_sam0_tc_module_reload_act
mbed_official 579:53297373a894 226 * <table>
mbed_official 579:53297373a894 227 * <caption>TC Module Reload Actions</caption>
mbed_official 579:53297373a894 228 * <tr>
mbed_official 579:53297373a894 229 * <th>Reload action</th>
mbed_official 579:53297373a894 230 * <th>Description</th>
mbed_official 579:53297373a894 231 * </tr>
mbed_official 579:53297373a894 232 * <tr>
mbed_official 579:53297373a894 233 * <td>\ref TC_RELOAD_ACTION_GCLK </td>
mbed_official 579:53297373a894 234 * <td>Reload TC counter value on next GCLK cycle. Leave prescaler
mbed_official 579:53297373a894 235 * as-is.</td>
mbed_official 579:53297373a894 236 * </tr>
mbed_official 579:53297373a894 237 * <tr>
mbed_official 579:53297373a894 238 * <td>\ref TC_RELOAD_ACTION_PRESC </td>
mbed_official 579:53297373a894 239 * <td>Reloads TC counter value on next prescaler clock. Leave prescaler
mbed_official 579:53297373a894 240 * as-is.</td>
mbed_official 579:53297373a894 241 * </tr>
mbed_official 579:53297373a894 242 * <tr>
mbed_official 579:53297373a894 243 * <td> \ref TC_RELOAD_ACTION_RESYNC </td>
mbed_official 579:53297373a894 244 * <td>Reload TC counter value on next GCLK cycle. Clear prescaler to
mbed_official 579:53297373a894 245 * zero.</td>
mbed_official 579:53297373a894 246 * </tr>
mbed_official 579:53297373a894 247 * </table>
mbed_official 579:53297373a894 248 *
mbed_official 579:53297373a894 249 * The reload action to use will depend on the specific application being
mbed_official 579:53297373a894 250 * implemented. One example is when an external trigger for a reload occurs; if
mbed_official 579:53297373a894 251 * the TC uses the prescaler, the counter in the prescaler should not have a
mbed_official 579:53297373a894 252 * value between zero and the division factor. The TC counter and the counter
mbed_official 579:53297373a894 253 * in the prescaler should both start at zero. When the counter is set to
mbed_official 579:53297373a894 254 * re-trigger when it reaches the maximum value on the other hand, this is not the
mbed_official 579:53297373a894 255 * right option to use. In such a case it would be better if the prescaler is
mbed_official 579:53297373a894 256 * left unaltered when the re-trigger happens, letting the counter reset on the
mbed_official 579:53297373a894 257 * next GCLK cycle.
mbed_official 579:53297373a894 258 *
mbed_official 579:53297373a894 259 * \subsection asfdoc_sam0_tc_module_overview_compare_match Compare Match Operations
mbed_official 579:53297373a894 260 * In compare match operation, Compare/Capture registers are used in comparison
mbed_official 579:53297373a894 261 * with the counter value. When the timer's count value matches the value of a
mbed_official 579:53297373a894 262 * compare channel, a user defined action can be taken.
mbed_official 579:53297373a894 263 *
mbed_official 579:53297373a894 264 * \subsubsection asfdoc_sam0_tc_module_overview_compare_match_timer Basic Timer
mbed_official 579:53297373a894 265 *
mbed_official 579:53297373a894 266 * A Basic Timer is a simple application where compare match operations is used
mbed_official 579:53297373a894 267 * to determine when a specific period has elapsed. In Basic Timer operations,
mbed_official 579:53297373a894 268 * one or more values in the module's Compare/Capture registers are used to
mbed_official 579:53297373a894 269 * specify the time (as a number of prescaled GCLK cycles) when an action should
mbed_official 579:53297373a894 270 * be taken by the microcontroller. This can be an Interrupt Service Routine
mbed_official 579:53297373a894 271 * (ISR), event generator via the event system, or a software flag that is
mbed_official 579:53297373a894 272 * polled via the user application.
mbed_official 579:53297373a894 273 *
mbed_official 579:53297373a894 274 * \subsubsection asfdoc_sam0_tc_module_overview_compare_match_wg Waveform Generation
mbed_official 579:53297373a894 275 *
mbed_official 579:53297373a894 276 * Waveform generation enables the TC module to generate square waves, or if
mbed_official 579:53297373a894 277 * combined with an external passive low-pass filter; analog waveforms.
mbed_official 579:53297373a894 278 *
mbed_official 579:53297373a894 279 * \subsubsection asfdoc_sam0_tc_module_overview_compare_match_wg_pwm Waveform Generation - PWM
mbed_official 579:53297373a894 280 *
mbed_official 579:53297373a894 281 * Pulse width modulation is a form of waveform generation and a signalling
mbed_official 579:53297373a894 282 * technique that can be useful in many situations. When PWM mode is used,
mbed_official 579:53297373a894 283 * a digital pulse train with a configurable frequency and duty cycle can be
mbed_official 579:53297373a894 284 * generated by the TC module and output to a GPIO pin of the device.
mbed_official 579:53297373a894 285 *
mbed_official 579:53297373a894 286 * Often PWM is used to communicate a control or information parameter to an
mbed_official 579:53297373a894 287 * external circuit or component. Differing impedances of the source generator
mbed_official 579:53297373a894 288 * and sink receiver circuits is less of an issue when using PWM compared to
mbed_official 579:53297373a894 289 * using an analog voltage value, as noise will not generally affect the
mbed_official 579:53297373a894 290 * signal's integrity to a meaningful extent.
mbed_official 579:53297373a894 291 *
mbed_official 579:53297373a894 292 * \ref asfdoc_sam0_tc_module_pwm_normal_diag "The figure below" illustrates
mbed_official 579:53297373a894 293 * operations and different states of the counter and its output when running
mbed_official 579:53297373a894 294 * the counter in PWM normal mode. As can be seen, the TOP value is unchanged
mbed_official 579:53297373a894 295 * and is set to MAX. The compare match value is changed at several points to
mbed_official 579:53297373a894 296 * illustrate the resulting waveform output changes. The PWM output is set to
mbed_official 579:53297373a894 297 * normal (i.e. non-inverted) output mode.
mbed_official 579:53297373a894 298 *
mbed_official 579:53297373a894 299 * \anchor asfdoc_sam0_tc_module_pwm_normal_diag
mbed_official 579:53297373a894 300 * \image html pwm_normal_ex.svg "Example of PWM in Normal Mode, and Different Counter Operations"
mbed_official 579:53297373a894 301 *
mbed_official 579:53297373a894 302 *
mbed_official 579:53297373a894 303 * In \ref asfdoc_sam0_tc_module_pwm_match_diag "the figure below", the
mbed_official 579:53297373a894 304 * counter is set to generate PWM in Match mode. The PWM output is inverted via
mbed_official 579:53297373a894 305 * the appropriate configuration option in the TC driver configuration
mbed_official 579:53297373a894 306 * structure. In this example, the counter value is changed once, but the
mbed_official 579:53297373a894 307 * compare match value is kept unchanged. As can be seen, it is possible to
mbed_official 579:53297373a894 308 * change the TOP value when running in PWM match mode.
mbed_official 579:53297373a894 309 *
mbed_official 579:53297373a894 310 * \anchor asfdoc_sam0_tc_module_pwm_match_diag
mbed_official 579:53297373a894 311 * \image html pwm_match_ex.svg "Example of PWM in Match Mode, and Different Counter Operations"
mbed_official 579:53297373a894 312 *
mbed_official 579:53297373a894 313 * \subsubsection asfdoc_sam0_tc_module_overview_compare_match_wg_freq Waveform Generation - Frequency
mbed_official 579:53297373a894 314 *
mbed_official 579:53297373a894 315 * Frequency Generation mode is in many ways identical to PWM
mbed_official 579:53297373a894 316 * generation. However, in Frequency Generation a toggle only occurs
mbed_official 579:53297373a894 317 * on the output when a match on a capture channels occurs. When the
mbed_official 579:53297373a894 318 * match is made, the timer value is reset, resulting in a variable
mbed_official 579:53297373a894 319 * frequency square wave with a fixed 50% duty cycle.
mbed_official 579:53297373a894 320 *
mbed_official 579:53297373a894 321 * \subsubsection asfdoc_sam0_tc_module_overview_compare_match_capt Capture Operations
mbed_official 579:53297373a894 322 *
mbed_official 579:53297373a894 323 * In capture operations, any event from the event system or a pin change can
mbed_official 579:53297373a894 324 * trigger a capture of the counter value. This captured counter value can be
mbed_official 579:53297373a894 325 * used as a timestamp for the event, or it can be used in frequency and pulse
mbed_official 579:53297373a894 326 * width capture.
mbed_official 579:53297373a894 327 *
mbed_official 579:53297373a894 328 * \subsubsection asfdoc_sam0_tc_module_overview_compare_match_capt_event_capture Capture Operations - Event
mbed_official 579:53297373a894 329 *
mbed_official 579:53297373a894 330 * Event capture is a simple use of the capture functionality,
mbed_official 579:53297373a894 331 * designed to create timestamps for specific events. When the TC
mbed_official 579:53297373a894 332 * module's input capture pin is externally toggled, the current timer
mbed_official 579:53297373a894 333 * count value is copied into a buffered register which can then be
mbed_official 579:53297373a894 334 * read out by the user application.
mbed_official 579:53297373a894 335 *
mbed_official 579:53297373a894 336 * Note that when performing any capture operation, there is a risk that the
mbed_official 579:53297373a894 337 * counter reaches its top value (MAX) when counting up, or the bottom value
mbed_official 579:53297373a894 338 * (zero) when counting down, before the capture event occurs. This can distort
mbed_official 579:53297373a894 339 * the result, making event timestamps to appear shorter than reality; the
mbed_official 579:53297373a894 340 * user application should check for timer overflow when reading a capture
mbed_official 579:53297373a894 341 * result in order to detect this situation and perform an appropriate
mbed_official 579:53297373a894 342 * adjustment.
mbed_official 579:53297373a894 343 *
mbed_official 579:53297373a894 344 * Before checking for a new capture, \ref TC_STATUS_COUNT_OVERFLOW
mbed_official 579:53297373a894 345 * should be checked. The response to an overflow error is left to the user
mbed_official 579:53297373a894 346 * application, however it may be necessary to clear both the capture overflow
mbed_official 579:53297373a894 347 * flag and the capture flag upon each capture reading.
mbed_official 579:53297373a894 348 *
mbed_official 579:53297373a894 349 * \subsubsection asfdoc_sam0_tc_module_overview_compare_match_capt_pwc Capture Operations - Pulse Width
mbed_official 579:53297373a894 350 *
mbed_official 579:53297373a894 351 * Pulse Width Capture mode makes it possible to measure the pulse width and
mbed_official 579:53297373a894 352 * period of PWM signals. This mode uses two capture channels of the counter.
mbed_official 579:53297373a894 353 * This means that the counter module used for Pulse Width Capture can not be
mbed_official 579:53297373a894 354 * used for any other purpose. There are two modes for pulse width capture;
mbed_official 579:53297373a894 355 * Pulse Width Period (PWP) and Period Pulse Width (PPW). In PWP mode, capture
mbed_official 579:53297373a894 356 * channel 0 is used for storing the pulse width and capture channel 1 stores
mbed_official 579:53297373a894 357 * the observed period. While in PPW mode, the roles of the two capture channels
mbed_official 579:53297373a894 358 * is reversed.
mbed_official 579:53297373a894 359 *
mbed_official 579:53297373a894 360 * As in the above example it is necessary to poll on interrupt flags to see
mbed_official 579:53297373a894 361 * if a new capture has happened and check that a capture overflow error has
mbed_official 579:53297373a894 362 * not occurred.
mbed_official 579:53297373a894 363 *
mbed_official 579:53297373a894 364 * \subsection asfdoc_sam0_tc_module_overview_oneshot One-shot Mode
mbed_official 579:53297373a894 365 *
mbed_official 579:53297373a894 366 * TC modules can be configured into a one-shot mode. When configured in this
mbed_official 579:53297373a894 367 * manner, starting the timer will cause it to count until the next overflow
mbed_official 579:53297373a894 368 * or underflow condition before automatically halting, waiting to be manually
mbed_official 579:53297373a894 369 * triggered by the user application software or an event signal from the event
mbed_official 579:53297373a894 370 * system.
mbed_official 579:53297373a894 371 *
mbed_official 579:53297373a894 372 * \subsubsection asfdoc_sam0_tc_module_overview_inversion Wave Generation Output Inversion
mbed_official 579:53297373a894 373 *
mbed_official 579:53297373a894 374 * The output of the wave generation can be inverted by hardware if desired,
mbed_official 579:53297373a894 375 * resulting in the logically inverted value being output to the configured
mbed_official 579:53297373a894 376 * device GPIO pin.
mbed_official 579:53297373a894 377 *
mbed_official 579:53297373a894 378 *
mbed_official 579:53297373a894 379 * \section asfdoc_sam0_tc_special_considerations Special Considerations
mbed_official 579:53297373a894 380 *
mbed_official 579:53297373a894 381 * The number of capture compare registers in each TC module is dependent on
mbed_official 579:53297373a894 382 * the specific SAM device being used, and in some cases the counter size.
mbed_official 579:53297373a894 383 *
mbed_official 579:53297373a894 384 * The maximum amount of capture compare registers available in any SAM
mbed_official 579:53297373a894 385 * device is two when running in 32-bit mode and four in 8- and 16-bit modes.
mbed_official 579:53297373a894 386 *
mbed_official 579:53297373a894 387 *
mbed_official 579:53297373a894 388 * \section asfdoc_sam0_tc_extra_info Extra Information
mbed_official 579:53297373a894 389 *
mbed_official 579:53297373a894 390 * For extra information, see \ref asfdoc_sam0_tc_extra. This includes:
mbed_official 579:53297373a894 391 * - \ref asfdoc_sam0_tc_extra_acronyms
mbed_official 579:53297373a894 392 * - \ref asfdoc_sam0_tc_extra_dependencies
mbed_official 579:53297373a894 393 * - \ref asfdoc_sam0_tc_extra_errata
mbed_official 579:53297373a894 394 * - \ref asfdoc_sam0_tc_extra_history
mbed_official 579:53297373a894 395 *
mbed_official 579:53297373a894 396 *
mbed_official 579:53297373a894 397 * \section asfdoc_sam0_tc_examples Examples
mbed_official 579:53297373a894 398 *
mbed_official 579:53297373a894 399 * For a list of examples related to this driver, see
mbed_official 579:53297373a894 400 * \ref asfdoc_sam0_tc_exqsg.
mbed_official 579:53297373a894 401 *
mbed_official 579:53297373a894 402 * \section asfdoc_sam0_tc_api_overview API Overview
mbed_official 579:53297373a894 403 * @{
mbed_official 579:53297373a894 404 */
mbed_official 579:53297373a894 405
mbed_official 579:53297373a894 406 #include <compiler.h>
mbed_official 579:53297373a894 407 #include <clock.h>
mbed_official 579:53297373a894 408 #include <gclk.h>
mbed_official 579:53297373a894 409 #include <pinmux.h>
mbed_official 579:53297373a894 410
mbed_official 579:53297373a894 411 /**
mbed_official 579:53297373a894 412 * Define port features set according to different device family
mbed_official 579:53297373a894 413 * @{
mbed_official 579:53297373a894 414 */
mbed_official 579:53297373a894 415 #if (SAML21) || defined(__DOXYGEN__)
mbed_official 579:53297373a894 416 /** TC double buffered */
mbed_official 579:53297373a894 417 # define FEATURE_TC_DOUBLE_BUFFERED
mbed_official 579:53297373a894 418 /** SYNCBUSY scheme version 2 */
mbed_official 579:53297373a894 419 # define FEATURE_TC_SYNCBUSY_SCHEME_VERSION_2
mbed_official 579:53297373a894 420 /** TC time stamp capture and pulse width capture */
mbed_official 579:53297373a894 421 # define FEATURE_TC_STAMP_PW_CAPTURE
mbed_official 579:53297373a894 422 /** Read synchronization of COUNT*/
mbed_official 579:53297373a894 423 # define FEATURE_TC_READ_SYNC
mbed_official 579:53297373a894 424 /** IO pin edge capture*/
mbed_official 579:53297373a894 425 # define FEATURE_TC_IO_CAPTURE
mbed_official 579:53297373a894 426 #endif
mbed_official 579:53297373a894 427 /*@}*/
mbed_official 579:53297373a894 428
mbed_official 579:53297373a894 429 #if !defined(__DOXYGEN__)
mbed_official 579:53297373a894 430 #if SAMD20 || SAML21
mbed_official 579:53297373a894 431 # define TC_INSTANCE_OFFSET 0
mbed_official 579:53297373a894 432 #endif
mbed_official 579:53297373a894 433 #if defined(SAMD21) || defined(SAMR21)
mbed_official 579:53297373a894 434 //#if SAMD21 || SAMR21
mbed_official 579:53297373a894 435 # define TC_INSTANCE_OFFSET 3
mbed_official 579:53297373a894 436 #endif
mbed_official 579:53297373a894 437 #if SAMD10 || SAMD11
mbed_official 579:53297373a894 438 # define TC_INSTANCE_OFFSET 1
mbed_official 579:53297373a894 439 #endif
mbed_official 579:53297373a894 440
mbed_official 579:53297373a894 441 #if SAMD20
mbed_official 579:53297373a894 442 # define NUMBER_OF_COMPARE_CAPTURE_CHANNELS TC0_CC8_NUM
mbed_official 579:53297373a894 443 #elif SAML21
mbed_official 579:53297373a894 444 # define NUMBER_OF_COMPARE_CAPTURE_CHANNELS TC0_CC_NUM
mbed_official 579:53297373a894 445 #elif SAMD10 || SAMD11
mbed_official 579:53297373a894 446 # define NUMBER_OF_COMPARE_CAPTURE_CHANNELS TC1_CC8_NUM
mbed_official 579:53297373a894 447 #else
mbed_official 579:53297373a894 448 # define NUMBER_OF_COMPARE_CAPTURE_CHANNELS TC3_CC8_NUM
mbed_official 579:53297373a894 449 /* Same number for 8-, 16- and 32-bit TC and all TC instances */
mbed_official 579:53297373a894 450 #endif
mbed_official 579:53297373a894 451
mbed_official 579:53297373a894 452 /** TC Instance MAX ID Number. */
mbed_official 579:53297373a894 453 #if SAMD20E || SAMD21G || SAMD21E || SAMR21
mbed_official 579:53297373a894 454 #define TC_INST_MAX_ID 5
mbed_official 579:53297373a894 455 #elif SAML21
mbed_official 579:53297373a894 456 #define TC_INST_MAX_ID 4
mbed_official 579:53297373a894 457 #elif SAMD10 || SAMD11
mbed_official 579:53297373a894 458 #define TC_INST_MAX_ID 2
mbed_official 579:53297373a894 459 #else
mbed_official 579:53297373a894 460 #define TC_INST_MAX_ID 7
mbed_official 579:53297373a894 461 #endif
mbed_official 579:53297373a894 462
mbed_official 579:53297373a894 463 #endif
mbed_official 579:53297373a894 464
mbed_official 579:53297373a894 465 //#if TC_ASYNC == true // TEMP: Commented by V
mbed_official 579:53297373a894 466 # include <system_interrupt.h>
mbed_official 579:53297373a894 467 //#endif
mbed_official 579:53297373a894 468
mbed_official 579:53297373a894 469 #ifdef __cplusplus
mbed_official 579:53297373a894 470 extern "C" {
mbed_official 579:53297373a894 471 #endif
mbed_official 579:53297373a894 472
mbed_official 579:53297373a894 473 //#if TC_ASYNC == true // TEMP: Commented by V
mbed_official 579:53297373a894 474 /** Enum for the possible callback types for the TC module. */
mbed_official 579:53297373a894 475 enum tc_callback {
mbed_official 579:53297373a894 476 /** Callback for TC overflow. */
mbed_official 579:53297373a894 477 TC_CALLBACK_OVERFLOW,
mbed_official 579:53297373a894 478 /** Callback for capture overflow error. */
mbed_official 579:53297373a894 479 TC_CALLBACK_ERROR,
mbed_official 579:53297373a894 480 /** Callback for capture compare channel 0. */
mbed_official 579:53297373a894 481 TC_CALLBACK_CC_CHANNEL0,
mbed_official 579:53297373a894 482 /** Callback for capture compare channel 1. */
mbed_official 579:53297373a894 483 TC_CALLBACK_CC_CHANNEL1,
mbed_official 579:53297373a894 484 # if !defined(__DOXYGEN__)
mbed_official 579:53297373a894 485 /** Number of available callbacks. */
mbed_official 579:53297373a894 486 TC_CALLBACK_N,
mbed_official 579:53297373a894 487 # endif
mbed_official 579:53297373a894 488 };
mbed_official 579:53297373a894 489 //#endif
mbed_official 579:53297373a894 490
mbed_official 579:53297373a894 491 /**
mbed_official 579:53297373a894 492 * \name Module Status Flags
mbed_official 579:53297373a894 493 *
mbed_official 579:53297373a894 494 * TC status flags, returned by \ref tc_get_status() and cleared by
mbed_official 579:53297373a894 495 * \ref tc_clear_status().
mbed_official 579:53297373a894 496 *
mbed_official 579:53297373a894 497 * @{
mbed_official 579:53297373a894 498 */
mbed_official 579:53297373a894 499
mbed_official 579:53297373a894 500 /** Timer channel 0 has matched against its compare value, or has captured a
mbed_official 579:53297373a894 501 * new value.
mbed_official 579:53297373a894 502 */
mbed_official 579:53297373a894 503 #define TC_STATUS_CHANNEL_0_MATCH (1UL << 0)
mbed_official 579:53297373a894 504
mbed_official 579:53297373a894 505 /** Timer channel 1 has matched against its compare value, or has captured a
mbed_official 579:53297373a894 506 * new value.
mbed_official 579:53297373a894 507 */
mbed_official 579:53297373a894 508 #define TC_STATUS_CHANNEL_1_MATCH (1UL << 1)
mbed_official 579:53297373a894 509
mbed_official 579:53297373a894 510 /** Timer register synchronization has completed, and the synchronized count
mbed_official 579:53297373a894 511 * value may be read.
mbed_official 579:53297373a894 512 */
mbed_official 579:53297373a894 513 #define TC_STATUS_SYNC_READY (1UL << 2)
mbed_official 579:53297373a894 514
mbed_official 579:53297373a894 515 /** A new value was captured before the previous value was read, resulting in
mbed_official 579:53297373a894 516 * lost data.
mbed_official 579:53297373a894 517 */
mbed_official 579:53297373a894 518 #define TC_STATUS_CAPTURE_OVERFLOW (1UL << 3)
mbed_official 579:53297373a894 519
mbed_official 579:53297373a894 520 /** The timer count value has overflowed from its maximum value to its minimum
mbed_official 579:53297373a894 521 * when counting upward, or from its minimum value to its maximum when
mbed_official 579:53297373a894 522 * counting downward.
mbed_official 579:53297373a894 523 */
mbed_official 579:53297373a894 524 #define TC_STATUS_COUNT_OVERFLOW (1UL << 4)
mbed_official 579:53297373a894 525
mbed_official 579:53297373a894 526 #ifdef FEATURE_TC_DOUBLE_BUFFERED
mbed_official 579:53297373a894 527 /** Channel 0 compare or capture buffer valid. */
mbed_official 579:53297373a894 528 #define TC_STATUS_CHN0_BUFFER_VALID (1UL << 5)
mbed_official 579:53297373a894 529 /** Channel 1 compare or capture buffer valid. */
mbed_official 579:53297373a894 530 #define TC_STATUS_CHN1_BUFFER_VALID (1UL << 6)
mbed_official 579:53297373a894 531 /** Period buffer valid. */
mbed_official 579:53297373a894 532 #define TC_STATUS_PERIOD_BUFFER_VALID (1UL << 7)
mbed_official 579:53297373a894 533 #endif
mbed_official 579:53297373a894 534 /** @} */
mbed_official 579:53297373a894 535
mbed_official 579:53297373a894 536 /**
mbed_official 579:53297373a894 537 * \brief Index of the compare capture channels.
mbed_official 579:53297373a894 538 *
mbed_official 579:53297373a894 539 * This enum is used to specify which capture/compare channel to do
mbed_official 579:53297373a894 540 * operations on.
mbed_official 579:53297373a894 541 */
mbed_official 579:53297373a894 542 enum tc_compare_capture_channel {
mbed_official 579:53297373a894 543 /** Index of compare capture channel 0. */
mbed_official 579:53297373a894 544 TC_COMPARE_CAPTURE_CHANNEL_0,
mbed_official 579:53297373a894 545 /** Index of compare capture channel 1. */
mbed_official 579:53297373a894 546 TC_COMPARE_CAPTURE_CHANNEL_1,
mbed_official 579:53297373a894 547 };
mbed_official 579:53297373a894 548
mbed_official 579:53297373a894 549 /** TC wave generation mode. */
mbed_official 579:53297373a894 550 #if SAML21
mbed_official 579:53297373a894 551 #define TC_WAVE_GENERATION_NORMAL_FREQ_MODE TC_WAVE_WAVEGEN_NFRQ
mbed_official 579:53297373a894 552 #define TC_WAVE_GENERATION_MATCH_FREQ_MODE TC_WAVE_WAVEGEN_MFRQ
mbed_official 579:53297373a894 553 #define TC_WAVE_GENERATION_NORMAL_PWM_MODE TC_WAVE_WAVEGEN_NPWM
mbed_official 579:53297373a894 554 #define TC_WAVE_GENERATION_MATCH_PWM_MODE TC_WAVE_WAVEGEN_MPWM
mbed_official 579:53297373a894 555 #else
mbed_official 579:53297373a894 556 #define TC_WAVE_GENERATION_NORMAL_FREQ_MODE TC_CTRLA_WAVEGEN_NFRQ
mbed_official 579:53297373a894 557 #define TC_WAVE_GENERATION_MATCH_FREQ_MODE TC_CTRLA_WAVEGEN_MFRQ
mbed_official 579:53297373a894 558 #define TC_WAVE_GENERATION_NORMAL_PWM_MODE TC_CTRLA_WAVEGEN_NPWM
mbed_official 579:53297373a894 559 #define TC_WAVE_GENERATION_MATCH_PWM_MODE TC_CTRLA_WAVEGEN_MPWM
mbed_official 579:53297373a894 560 #endif
mbed_official 579:53297373a894 561
mbed_official 579:53297373a894 562 /**
mbed_official 579:53297373a894 563 * \brief TC wave generation mode enum.
mbed_official 579:53297373a894 564 *
mbed_official 579:53297373a894 565 * This enum is used to select which mode to run the wave
mbed_official 579:53297373a894 566 * generation in.
mbed_official 579:53297373a894 567 *
mbed_official 579:53297373a894 568 */
mbed_official 579:53297373a894 569 enum tc_wave_generation {
mbed_official 579:53297373a894 570 /** Top is maximum, except in 8-bit counter size where it is the PER
mbed_official 579:53297373a894 571 * register.
mbed_official 579:53297373a894 572 */
mbed_official 579:53297373a894 573 TC_WAVE_GENERATION_NORMAL_FREQ = TC_WAVE_GENERATION_NORMAL_FREQ_MODE,
mbed_official 579:53297373a894 574
mbed_official 579:53297373a894 575 /** Top is CC0, except in 8-bit counter size where it is the PER
mbed_official 579:53297373a894 576 * register.
mbed_official 579:53297373a894 577 */
mbed_official 579:53297373a894 578 TC_WAVE_GENERATION_MATCH_FREQ = TC_WAVE_GENERATION_MATCH_FREQ_MODE,
mbed_official 579:53297373a894 579
mbed_official 579:53297373a894 580 /** Top is maximum, except in 8-bit counter size where it is the PER
mbed_official 579:53297373a894 581 * register.
mbed_official 579:53297373a894 582 */
mbed_official 579:53297373a894 583 TC_WAVE_GENERATION_NORMAL_PWM = TC_WAVE_GENERATION_NORMAL_PWM_MODE,
mbed_official 579:53297373a894 584
mbed_official 579:53297373a894 585 /** Top is CC0, except in 8-bit counter size where it is the PER
mbed_official 579:53297373a894 586 * register.
mbed_official 579:53297373a894 587 */
mbed_official 579:53297373a894 588 TC_WAVE_GENERATION_MATCH_PWM = TC_WAVE_GENERATION_MATCH_PWM_MODE,
mbed_official 579:53297373a894 589 };
mbed_official 579:53297373a894 590
mbed_official 579:53297373a894 591 /**
mbed_official 579:53297373a894 592 * \brief Specifies if the counter is 8-, 16-, or 32-bit.
mbed_official 579:53297373a894 593 *
mbed_official 579:53297373a894 594 * This enum specifies the maximum value it is possible to count to.
mbed_official 579:53297373a894 595 */
mbed_official 579:53297373a894 596 enum tc_counter_size {
mbed_official 579:53297373a894 597 /** The counter's maximum value is 0xFF, the period register is
mbed_official 579:53297373a894 598 * available to be used as top value.
mbed_official 579:53297373a894 599 */
mbed_official 579:53297373a894 600 TC_COUNTER_SIZE_8BIT = TC_CTRLA_MODE_COUNT8,
mbed_official 579:53297373a894 601
mbed_official 579:53297373a894 602 /** The counter's maximum value is 0xFFFF. There is no separate
mbed_official 579:53297373a894 603 * period register, to modify top one of the capture compare
mbed_official 579:53297373a894 604 * registers has to be used. This limits the amount of
mbed_official 579:53297373a894 605 * available channels.
mbed_official 579:53297373a894 606 */
mbed_official 579:53297373a894 607 TC_COUNTER_SIZE_16BIT = TC_CTRLA_MODE_COUNT16,
mbed_official 579:53297373a894 608
mbed_official 579:53297373a894 609 /** The counter's maximum value is 0xFFFFFFFF. There is no separate
mbed_official 579:53297373a894 610 * period register, to modify top one of the capture compare
mbed_official 579:53297373a894 611 * registers has to be used. This limits the amount of
mbed_official 579:53297373a894 612 * available channels.
mbed_official 579:53297373a894 613 */
mbed_official 579:53297373a894 614 TC_COUNTER_SIZE_32BIT = TC_CTRLA_MODE_COUNT32,
mbed_official 579:53297373a894 615 };
mbed_official 579:53297373a894 616
mbed_official 579:53297373a894 617 /**
mbed_official 579:53297373a894 618 * \brief TC Counter reload action enum.
mbed_official 579:53297373a894 619 *
mbed_official 579:53297373a894 620 * This enum specify how the counter and prescaler should reload.
mbed_official 579:53297373a894 621 */
mbed_official 579:53297373a894 622 enum tc_reload_action {
mbed_official 579:53297373a894 623 /** The counter is reloaded/reset on the next GCLK and starts
mbed_official 579:53297373a894 624 * counting on the prescaler clock.
mbed_official 579:53297373a894 625 */
mbed_official 579:53297373a894 626 TC_RELOAD_ACTION_GCLK = TC_CTRLA_PRESCSYNC_GCLK,
mbed_official 579:53297373a894 627
mbed_official 579:53297373a894 628 /** The counter is reloaded/reset on the next prescaler clock.
mbed_official 579:53297373a894 629 */
mbed_official 579:53297373a894 630 TC_RELOAD_ACTION_PRESC = TC_CTRLA_PRESCSYNC_PRESC,
mbed_official 579:53297373a894 631
mbed_official 579:53297373a894 632 /** The counter is reloaded/reset on the next GCLK, and the
mbed_official 579:53297373a894 633 * prescaler is restarted as well.
mbed_official 579:53297373a894 634 */
mbed_official 579:53297373a894 635 TC_RELOAD_ACTION_RESYNC = TC_CTRLA_PRESCSYNC_RESYNC,
mbed_official 579:53297373a894 636 };
mbed_official 579:53297373a894 637
mbed_official 579:53297373a894 638 /**
mbed_official 579:53297373a894 639 * \brief TC clock prescaler values.
mbed_official 579:53297373a894 640 *
mbed_official 579:53297373a894 641 * This enum is used to choose the clock prescaler
mbed_official 579:53297373a894 642 * configuration. The prescaler divides the clock frequency of the TC
mbed_official 579:53297373a894 643 * module to make the counter count slower.
mbed_official 579:53297373a894 644 */
mbed_official 579:53297373a894 645 enum tc_clock_prescaler {
mbed_official 579:53297373a894 646 /** Divide clock by 1. */
mbed_official 579:53297373a894 647 TC_CLOCK_PRESCALER_DIV1 = TC_CTRLA_PRESCALER(0),
mbed_official 579:53297373a894 648 /** Divide clock by 2. */
mbed_official 579:53297373a894 649 TC_CLOCK_PRESCALER_DIV2 = TC_CTRLA_PRESCALER(1),
mbed_official 579:53297373a894 650 /** Divide clock by 4. */
mbed_official 579:53297373a894 651 TC_CLOCK_PRESCALER_DIV4 = TC_CTRLA_PRESCALER(2),
mbed_official 579:53297373a894 652 /** Divide clock by 8. */
mbed_official 579:53297373a894 653 TC_CLOCK_PRESCALER_DIV8 = TC_CTRLA_PRESCALER(3),
mbed_official 579:53297373a894 654 /** Divide clock by 16. */
mbed_official 579:53297373a894 655 TC_CLOCK_PRESCALER_DIV16 = TC_CTRLA_PRESCALER(4),
mbed_official 579:53297373a894 656 /** Divide clock by 64. */
mbed_official 579:53297373a894 657 TC_CLOCK_PRESCALER_DIV64 = TC_CTRLA_PRESCALER(5),
mbed_official 579:53297373a894 658 /** Divide clock by 256. */
mbed_official 579:53297373a894 659 TC_CLOCK_PRESCALER_DIV256 = TC_CTRLA_PRESCALER(6),
mbed_official 579:53297373a894 660 /** Divide clock by 1024. */
mbed_official 579:53297373a894 661 TC_CLOCK_PRESCALER_DIV1024 = TC_CTRLA_PRESCALER(7),
mbed_official 579:53297373a894 662 };
mbed_official 579:53297373a894 663
mbed_official 579:53297373a894 664 /**
mbed_official 579:53297373a894 665 * \brief TC module count direction.
mbed_official 579:53297373a894 666 *
mbed_official 579:53297373a894 667 * Timer/Counter count direction.
mbed_official 579:53297373a894 668 */
mbed_official 579:53297373a894 669 enum tc_count_direction {
mbed_official 579:53297373a894 670 /** Timer should count upward from zero to MAX. */
mbed_official 579:53297373a894 671 TC_COUNT_DIRECTION_UP,
mbed_official 579:53297373a894 672
mbed_official 579:53297373a894 673 /** Timer should count downward to zero from MAX. */
mbed_official 579:53297373a894 674 TC_COUNT_DIRECTION_DOWN,
mbed_official 579:53297373a894 675 };
mbed_official 579:53297373a894 676
mbed_official 579:53297373a894 677 /** Waveform inversion mode. */
mbed_official 579:53297373a894 678 #if SAML21
mbed_official 579:53297373a894 679 #define TC_WAVEFORM_INVERT_CC0_MODE TC_DRVCTRL_INVEN(1)
mbed_official 579:53297373a894 680 #define TC_WAVEFORM_INVERT_CC1_MODE TC_DRVCTRL_INVEN(2)
mbed_official 579:53297373a894 681 #else
mbed_official 579:53297373a894 682 #define TC_WAVEFORM_INVERT_CC0_MODE TC_CTRLC_INVEN(1)
mbed_official 579:53297373a894 683 #define TC_WAVEFORM_INVERT_CC1_MODE TC_CTRLC_INVEN(2)
mbed_official 579:53297373a894 684 #endif
mbed_official 579:53297373a894 685
mbed_official 579:53297373a894 686 /**
mbed_official 579:53297373a894 687 * \brief Waveform inversion mode.
mbed_official 579:53297373a894 688 *
mbed_official 579:53297373a894 689 * Output waveform inversion mode.
mbed_official 579:53297373a894 690 */
mbed_official 579:53297373a894 691 enum tc_waveform_invert_output {
mbed_official 579:53297373a894 692 /** No inversion of the waveform output. */
mbed_official 579:53297373a894 693 TC_WAVEFORM_INVERT_OUTPUT_NONE = 0,
mbed_official 579:53297373a894 694 /** Invert output from compare channel 0. */
mbed_official 579:53297373a894 695 TC_WAVEFORM_INVERT_OUTPUT_CHANNEL_0 = TC_WAVEFORM_INVERT_CC0_MODE,
mbed_official 579:53297373a894 696 /** Invert output from compare channel 1. */
mbed_official 579:53297373a894 697 TC_WAVEFORM_INVERT_OUTPUT_CHANNEL_1 = TC_WAVEFORM_INVERT_CC1_MODE,
mbed_official 579:53297373a894 698 };
mbed_official 579:53297373a894 699
mbed_official 579:53297373a894 700 /**
mbed_official 579:53297373a894 701 * \brief Action to perform when the TC module is triggered by an event.
mbed_official 579:53297373a894 702 *
mbed_official 579:53297373a894 703 * Event action to perform when the module is triggered by an event.
mbed_official 579:53297373a894 704 */
mbed_official 579:53297373a894 705 enum tc_event_action {
mbed_official 579:53297373a894 706 /** No event action. */
mbed_official 579:53297373a894 707 TC_EVENT_ACTION_OFF = TC_EVCTRL_EVACT_OFF,
mbed_official 579:53297373a894 708 /** Re-trigger on event. */
mbed_official 579:53297373a894 709 TC_EVENT_ACTION_RETRIGGER = TC_EVCTRL_EVACT_RETRIGGER,
mbed_official 579:53297373a894 710 /** Increment counter on event. */
mbed_official 579:53297373a894 711 TC_EVENT_ACTION_INCREMENT_COUNTER = TC_EVCTRL_EVACT_COUNT,
mbed_official 579:53297373a894 712 /** Start counter on event. */
mbed_official 579:53297373a894 713 TC_EVENT_ACTION_START = TC_EVCTRL_EVACT_START,
mbed_official 579:53297373a894 714
mbed_official 579:53297373a894 715 /** Store period in capture register 0, pulse width in capture
mbed_official 579:53297373a894 716 * register 1.
mbed_official 579:53297373a894 717 */
mbed_official 579:53297373a894 718 TC_EVENT_ACTION_PPW = TC_EVCTRL_EVACT_PPW,
mbed_official 579:53297373a894 719
mbed_official 579:53297373a894 720 /** Store pulse width in capture register 0, period in capture
mbed_official 579:53297373a894 721 * register 1.
mbed_official 579:53297373a894 722 */
mbed_official 579:53297373a894 723 TC_EVENT_ACTION_PWP = TC_EVCTRL_EVACT_PWP,
mbed_official 579:53297373a894 724 #ifdef FEATURE_TC_STAMP_PW_CAPTURE
mbed_official 579:53297373a894 725 /** Time stamp capture. */
mbed_official 579:53297373a894 726 TC_EVENT_ACTION_STAMP = TC_EVCTRL_EVACT_STAMP,
mbed_official 579:53297373a894 727 /** Pulse width capture. */
mbed_official 579:53297373a894 728 TC_EVENT_ACTION_PW = TC_EVCTRL_EVACT_PW,
mbed_official 579:53297373a894 729 #endif
mbed_official 579:53297373a894 730 };
mbed_official 579:53297373a894 731
mbed_official 579:53297373a894 732 /**
mbed_official 579:53297373a894 733 * \brief TC event enable/disable structure.
mbed_official 579:53297373a894 734 *
mbed_official 579:53297373a894 735 * Event flags for the \ref tc_enable_events() and \ref tc_disable_events().
mbed_official 579:53297373a894 736 */
mbed_official 579:53297373a894 737 struct tc_events {
mbed_official 579:53297373a894 738 /** Generate an output event on a compare channel match. */
mbed_official 579:53297373a894 739 bool generate_event_on_compare_channel
mbed_official 579:53297373a894 740 [NUMBER_OF_COMPARE_CAPTURE_CHANNELS];
mbed_official 579:53297373a894 741 /** Generate an output event on counter overflow. */
mbed_official 579:53297373a894 742 bool generate_event_on_overflow;
mbed_official 579:53297373a894 743 /** Perform the configured event action when an incoming event is signalled. */
mbed_official 579:53297373a894 744 bool on_event_perform_action;
mbed_official 579:53297373a894 745 /** Specifies if the input event source is inverted, when used in PWP or
mbed_official 579:53297373a894 746 * PPW event action modes.
mbed_official 579:53297373a894 747 */
mbed_official 579:53297373a894 748 bool invert_event_input;
mbed_official 579:53297373a894 749 /** Specifies which event to trigger if an event is triggered. */
mbed_official 579:53297373a894 750 enum tc_event_action event_action;
mbed_official 579:53297373a894 751 };
mbed_official 579:53297373a894 752
mbed_official 579:53297373a894 753 /**
mbed_official 579:53297373a894 754 * \brief Configuration struct for TC module in 8-bit size counter mode.
mbed_official 579:53297373a894 755 */
mbed_official 579:53297373a894 756 struct tc_8bit_config {
mbed_official 579:53297373a894 757 /** Initial timer count value. */
mbed_official 579:53297373a894 758 uint8_t value;
mbed_official 579:53297373a894 759 /** Where to count to or from depending on the direction on the counter. */
mbed_official 579:53297373a894 760 uint8_t period;
mbed_official 579:53297373a894 761 /** Value to be used for compare match on each channel. */
mbed_official 579:53297373a894 762 uint8_t compare_capture_channel[NUMBER_OF_COMPARE_CAPTURE_CHANNELS];
mbed_official 579:53297373a894 763 };
mbed_official 579:53297373a894 764
mbed_official 579:53297373a894 765 /**
mbed_official 579:53297373a894 766 * \brief Configuration struct for TC module in 16-bit size counter mode.
mbed_official 579:53297373a894 767 */
mbed_official 579:53297373a894 768 struct tc_16bit_config {
mbed_official 579:53297373a894 769 /** Initial timer count value. */
mbed_official 579:53297373a894 770 uint16_t value;
mbed_official 579:53297373a894 771 /** Value to be used for compare match on each channel. */
mbed_official 579:53297373a894 772 uint16_t compare_capture_channel[NUMBER_OF_COMPARE_CAPTURE_CHANNELS];
mbed_official 579:53297373a894 773 };
mbed_official 579:53297373a894 774
mbed_official 579:53297373a894 775 /**
mbed_official 579:53297373a894 776 * \brief Configuration struct for TC module in 32-bit size counter mode.
mbed_official 579:53297373a894 777 */
mbed_official 579:53297373a894 778 struct tc_32bit_config {
mbed_official 579:53297373a894 779 /** Initial timer count value. */
mbed_official 579:53297373a894 780 uint32_t value;
mbed_official 579:53297373a894 781 /** Value to be used for compare match on each channel. */
mbed_official 579:53297373a894 782 uint32_t compare_capture_channel[NUMBER_OF_COMPARE_CAPTURE_CHANNELS];
mbed_official 579:53297373a894 783 };
mbed_official 579:53297373a894 784
mbed_official 579:53297373a894 785 /**
mbed_official 579:53297373a894 786 * \brief Configuration struct for TC module in 32-bit size counter mode.
mbed_official 579:53297373a894 787 */
mbed_official 579:53297373a894 788 struct tc_pwm_channel {
mbed_official 579:53297373a894 789 /** When \c true, PWM output for the given channel is enabled. */
mbed_official 579:53297373a894 790 bool enabled;
mbed_official 579:53297373a894 791 /** Specifies pin output for each channel. */
mbed_official 579:53297373a894 792 uint32_t pin_out;
mbed_official 579:53297373a894 793 /** Specifies MUX setting for each output channel pin. */
mbed_official 579:53297373a894 794 uint32_t pin_mux;
mbed_official 579:53297373a894 795 };
mbed_official 579:53297373a894 796
mbed_official 579:53297373a894 797 /**
mbed_official 579:53297373a894 798 * \brief TC configuration structure.
mbed_official 579:53297373a894 799 *
mbed_official 579:53297373a894 800 * Configuration struct for a TC instance. This structure should be
mbed_official 579:53297373a894 801 * initialized by the \ref tc_get_config_defaults function before being
mbed_official 579:53297373a894 802 * modified by the user application.
mbed_official 579:53297373a894 803 */
mbed_official 579:53297373a894 804 struct tc_config {
mbed_official 579:53297373a894 805 /** GCLK generator used to clock the peripheral. */
mbed_official 579:53297373a894 806 enum gclk_generator clock_source;
mbed_official 579:53297373a894 807
mbed_official 579:53297373a894 808 /** When \c true the module is enabled during standby. */
mbed_official 579:53297373a894 809 bool run_in_standby;
mbed_official 579:53297373a894 810 #if (SAML21)
mbed_official 579:53297373a894 811 /** Run on demand. */
mbed_official 579:53297373a894 812 bool on_demand;
mbed_official 579:53297373a894 813 #endif
mbed_official 579:53297373a894 814 /** Specifies either 8-, 16-, or 32-bit counter size. */
mbed_official 579:53297373a894 815 enum tc_counter_size counter_size;
mbed_official 579:53297373a894 816 /** Specifies the prescaler value for GCLK_TC. */
mbed_official 579:53297373a894 817 enum tc_clock_prescaler clock_prescaler;
mbed_official 579:53297373a894 818 /** Specifies which waveform generation mode to use. */
mbed_official 579:53297373a894 819 enum tc_wave_generation wave_generation;
mbed_official 579:53297373a894 820
mbed_official 579:53297373a894 821 /** Specifies the reload or reset time of the counter and prescaler
mbed_official 579:53297373a894 822 * resynchronization on a re-trigger event for the TC.
mbed_official 579:53297373a894 823 */
mbed_official 579:53297373a894 824 enum tc_reload_action reload_action;
mbed_official 579:53297373a894 825
mbed_official 579:53297373a894 826 /** Specifies which channel(s) to invert the waveform on.
mbed_official 579:53297373a894 827 For SAML21, it's also used to invert IO input pin. */
mbed_official 579:53297373a894 828 uint8_t waveform_invert_output;
mbed_official 579:53297373a894 829
mbed_official 579:53297373a894 830 /** Specifies which channel(s) to enable channel capture
mbed_official 579:53297373a894 831 * operation on.
mbed_official 579:53297373a894 832 */
mbed_official 579:53297373a894 833 bool enable_capture_on_channel[NUMBER_OF_COMPARE_CAPTURE_CHANNELS];
mbed_official 579:53297373a894 834 #ifdef FEATURE_TC_IO_CAPTURE
mbed_official 579:53297373a894 835 /** Specifies which channel(s) to enable I/O capture
mbed_official 579:53297373a894 836 * operation on.
mbed_official 579:53297373a894 837 */
mbed_official 579:53297373a894 838 bool enable_capture_on_IO[NUMBER_OF_COMPARE_CAPTURE_CHANNELS];
mbed_official 579:53297373a894 839 #endif
mbed_official 579:53297373a894 840
mbed_official 579:53297373a894 841 /** When \c true, one-shot will stop the TC on next hardware or software
mbed_official 579:53297373a894 842 * re-trigger event or overflow/underflow.
mbed_official 579:53297373a894 843 */
mbed_official 579:53297373a894 844 bool oneshot;
mbed_official 579:53297373a894 845
mbed_official 579:53297373a894 846 /** Specifies the direction for the TC to count. */
mbed_official 579:53297373a894 847 enum tc_count_direction count_direction;
mbed_official 579:53297373a894 848
mbed_official 579:53297373a894 849 /** Specifies the PWM channel for TC. */
mbed_official 579:53297373a894 850 struct tc_pwm_channel pwm_channel[NUMBER_OF_COMPARE_CAPTURE_CHANNELS];
mbed_official 579:53297373a894 851
mbed_official 579:53297373a894 852 /** Access the different counter size settings though this configuration member. */
mbed_official 579:53297373a894 853 union {
mbed_official 579:53297373a894 854 /** Struct for 8-bit specific timer configuration. */
mbed_official 579:53297373a894 855 struct tc_8bit_config counter_8_bit;
mbed_official 579:53297373a894 856 /** Struct for 16-bit specific timer configuration. */
mbed_official 579:53297373a894 857 struct tc_16bit_config counter_16_bit;
mbed_official 579:53297373a894 858 /** Struct for 32-bit specific timer configuration. */
mbed_official 579:53297373a894 859 struct tc_32bit_config counter_32_bit;
mbed_official 579:53297373a894 860 };
mbed_official 579:53297373a894 861
mbed_official 579:53297373a894 862 #ifdef FEATURE_TC_DOUBLE_BUFFERED
mbed_official 579:53297373a894 863 /** Set to \c true to enable double buffering write. When enabled any write
mbed_official 579:53297373a894 864 * through \ref tc_set_top_value(), \ref tc_set_compare_value() and
mbed_official 579:53297373a894 865 * will direct to the buffer register as buffered
mbed_official 579:53297373a894 866 * value, and the buffered value will be committed to effective register
mbed_official 579:53297373a894 867 * on UPDATE condition, if update is not locked.
mbed_official 579:53297373a894 868 */
mbed_official 579:53297373a894 869 bool double_buffering_enabled;
mbed_official 579:53297373a894 870 #endif
mbed_official 579:53297373a894 871 };
mbed_official 579:53297373a894 872
mbed_official 579:53297373a894 873
mbed_official 579:53297373a894 874 //#if TC_ASYNC == true // TEMP: Commented by V
mbed_official 579:53297373a894 875 /* Forward Declaration for the device instance. */
mbed_official 579:53297373a894 876 struct tc_module;
mbed_official 579:53297373a894 877
mbed_official 579:53297373a894 878 /* Type of the callback functions. */
mbed_official 579:53297373a894 879 typedef void (*tc_callback_t)(struct tc_module *const module);
mbed_official 579:53297373a894 880 //#endif
mbed_official 579:53297373a894 881
mbed_official 579:53297373a894 882 /**
mbed_official 579:53297373a894 883 * \brief TC software device instance structure.
mbed_official 579:53297373a894 884 *
mbed_official 579:53297373a894 885 * TC software instance structure, used to retain software state information
mbed_official 579:53297373a894 886 * of an associated hardware module instance.
mbed_official 579:53297373a894 887 *
mbed_official 579:53297373a894 888 * \note The fields of this structure should not be altered by the user
mbed_official 579:53297373a894 889 * application; they are reserved for module-internal use only.
mbed_official 579:53297373a894 890 */
mbed_official 579:53297373a894 891 struct tc_module {
mbed_official 579:53297373a894 892 #if !defined(__DOXYGEN__)
mbed_official 579:53297373a894 893 /** Hardware module pointer of the associated Timer/Counter peripheral. */
mbed_official 579:53297373a894 894 Tc *hw;
mbed_official 579:53297373a894 895
mbed_official 579:53297373a894 896 /** Size of the initialized Timer/Counter module configuration. */
mbed_official 579:53297373a894 897 enum tc_counter_size counter_size;
mbed_official 579:53297373a894 898 //# if TC_ASYNC == true // TEMP: Commented by V
mbed_official 579:53297373a894 899 /** Array of callbacks. */
mbed_official 579:53297373a894 900 tc_callback_t callback[TC_CALLBACK_N];
mbed_official 579:53297373a894 901 /** Bit mask for callbacks registered. */
mbed_official 579:53297373a894 902 uint8_t register_callback_mask;
mbed_official 579:53297373a894 903 /** Bit mask for callbacks enabled. */
mbed_official 579:53297373a894 904 uint8_t enable_callback_mask;
mbed_official 579:53297373a894 905 //# endif
mbed_official 579:53297373a894 906 #ifdef FEATURE_TC_DOUBLE_BUFFERED
mbed_official 579:53297373a894 907 /** Set to \c true to enable double buffering write. */
mbed_official 579:53297373a894 908 bool double_buffering_enabled;
mbed_official 579:53297373a894 909 #endif
mbed_official 579:53297373a894 910 #endif
mbed_official 579:53297373a894 911 };
mbed_official 579:53297373a894 912
mbed_official 579:53297373a894 913 #if !defined(__DOXYGEN__)
mbed_official 579:53297373a894 914 uint8_t _tc_get_inst_index(
mbed_official 579:53297373a894 915 Tc *const hw);
mbed_official 579:53297373a894 916 #endif
mbed_official 579:53297373a894 917
mbed_official 579:53297373a894 918 /**
mbed_official 579:53297373a894 919 * \name Driver Initialization and Configuration
mbed_official 579:53297373a894 920 * @{
mbed_official 579:53297373a894 921 */
mbed_official 579:53297373a894 922
mbed_official 579:53297373a894 923 /**
mbed_official 579:53297373a894 924 * \brief Determines if the hardware module(s) are currently synchronizing to
mbed_official 579:53297373a894 925 *the bus.
mbed_official 579:53297373a894 926 *
mbed_official 579:53297373a894 927 * Checks to see if the underlying hardware peripheral module(s) are currently
mbed_official 579:53297373a894 928 * synchronizing across multiple clock domains to the hardware bus. This
mbed_official 579:53297373a894 929 * function can be used to delay further operations on a module until such time
mbed_official 579:53297373a894 930 * that it is ready, to prevent blocking delays for synchronization in the
mbed_official 579:53297373a894 931 * user application.
mbed_official 579:53297373a894 932 *
mbed_official 579:53297373a894 933 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 934 *
mbed_official 579:53297373a894 935 * \return Synchronization status of the underlying hardware module(s).
mbed_official 579:53297373a894 936 *
mbed_official 579:53297373a894 937 * \retval false If the module has completed synchronization
mbed_official 579:53297373a894 938 * \retval true If the module synchronization is ongoing
mbed_official 579:53297373a894 939 */
mbed_official 579:53297373a894 940 static inline bool tc_is_syncing(
mbed_official 579:53297373a894 941 const struct tc_module *const module_inst)
mbed_official 579:53297373a894 942 {
mbed_official 579:53297373a894 943 /* Sanity check arguments */
mbed_official 579:53297373a894 944 Assert(module_inst);
mbed_official 579:53297373a894 945 Assert(module_inst->hw);
mbed_official 579:53297373a894 946
mbed_official 579:53297373a894 947 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 948 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 949
mbed_official 579:53297373a894 950 #if (SAML21)
mbed_official 579:53297373a894 951 return (tc_module->SYNCBUSY.reg);
mbed_official 579:53297373a894 952 #else
mbed_official 579:53297373a894 953 return (tc_module->STATUS.reg & TC_STATUS_SYNCBUSY);
mbed_official 579:53297373a894 954 #endif
mbed_official 579:53297373a894 955 }
mbed_official 579:53297373a894 956
mbed_official 579:53297373a894 957 /**
mbed_official 579:53297373a894 958 * \brief Initializes config with predefined default values.
mbed_official 579:53297373a894 959 *
mbed_official 579:53297373a894 960 * This function will initialize a given TC configuration structure to
mbed_official 579:53297373a894 961 * a set of known default values. This function should be called on
mbed_official 579:53297373a894 962 * any new instance of the configuration structures before being
mbed_official 579:53297373a894 963 * modified by the user application.
mbed_official 579:53297373a894 964 *
mbed_official 579:53297373a894 965 * The default configuration is as follows:
mbed_official 579:53297373a894 966 * \li GCLK generator 0 (GCLK main) clock source
mbed_official 579:53297373a894 967 * \li 16-bit counter size on the counter
mbed_official 579:53297373a894 968 * \li No prescaler
mbed_official 579:53297373a894 969 * \li Normal frequency wave generation
mbed_official 579:53297373a894 970 * \li GCLK reload action
mbed_official 579:53297373a894 971 * \li Don't run in standby
mbed_official 579:53297373a894 972 * \li Don't run on demand for SAML21
mbed_official 579:53297373a894 973 * \li No inversion of waveform output
mbed_official 579:53297373a894 974 * \li No capture enabled
mbed_official 579:53297373a894 975 * \li No I/O capture enabled for SAML21
mbed_official 579:53297373a894 976 * \li No event input enabled
mbed_official 579:53297373a894 977 * \li Count upward
mbed_official 579:53297373a894 978 * \li Don't perform one-shot operations
mbed_official 579:53297373a894 979 * \li No event action
mbed_official 579:53297373a894 980 * \li No channel 0 PWM output
mbed_official 579:53297373a894 981 * \li No channel 1 PWM output
mbed_official 579:53297373a894 982 * \li Counter starts on 0
mbed_official 579:53297373a894 983 * \li Capture compare channel 0 set to 0
mbed_official 579:53297373a894 984 * \li Capture compare channel 1 set to 0
mbed_official 579:53297373a894 985 * \li No PWM pin output enabled
mbed_official 579:53297373a894 986 * \li Pin and MUX configuration not set
mbed_official 579:53297373a894 987 * \li Double buffer disabled (if have this feature)
mbed_official 579:53297373a894 988 *
mbed_official 579:53297373a894 989 * \param[out] config Pointer to a TC module configuration structure to set
mbed_official 579:53297373a894 990 */
mbed_official 579:53297373a894 991 static inline void tc_get_config_defaults(
mbed_official 579:53297373a894 992 struct tc_config *const config)
mbed_official 579:53297373a894 993 {
mbed_official 579:53297373a894 994 /* Sanity check arguments */
mbed_official 579:53297373a894 995 Assert(config);
mbed_official 579:53297373a894 996
mbed_official 579:53297373a894 997 /* Write default config to config struct */
mbed_official 579:53297373a894 998 config->clock_source = GCLK_GENERATOR_0;
mbed_official 579:53297373a894 999 config->counter_size = TC_COUNTER_SIZE_16BIT;
mbed_official 579:53297373a894 1000 config->clock_prescaler = TC_CLOCK_PRESCALER_DIV1;
mbed_official 579:53297373a894 1001 config->wave_generation = TC_WAVE_GENERATION_NORMAL_FREQ;
mbed_official 579:53297373a894 1002 config->reload_action = TC_RELOAD_ACTION_GCLK;
mbed_official 579:53297373a894 1003 config->run_in_standby = false;
mbed_official 579:53297373a894 1004 #if (SAML21)
mbed_official 579:53297373a894 1005 config->on_demand = false;
mbed_official 579:53297373a894 1006 #endif
mbed_official 579:53297373a894 1007 config->waveform_invert_output = TC_WAVEFORM_INVERT_OUTPUT_NONE;
mbed_official 579:53297373a894 1008 config->enable_capture_on_channel[TC_COMPARE_CAPTURE_CHANNEL_0] = false;
mbed_official 579:53297373a894 1009 config->enable_capture_on_channel[TC_COMPARE_CAPTURE_CHANNEL_1] = false;
mbed_official 579:53297373a894 1010 #ifdef FEATURE_TC_IO_CAPTURE
mbed_official 579:53297373a894 1011 config->enable_capture_on_IO[TC_COMPARE_CAPTURE_CHANNEL_0] = false;
mbed_official 579:53297373a894 1012 config->enable_capture_on_IO[TC_COMPARE_CAPTURE_CHANNEL_1] = false;
mbed_official 579:53297373a894 1013 #endif
mbed_official 579:53297373a894 1014
mbed_official 579:53297373a894 1015 config->count_direction = TC_COUNT_DIRECTION_UP;
mbed_official 579:53297373a894 1016 config->oneshot = false;
mbed_official 579:53297373a894 1017
mbed_official 579:53297373a894 1018 config->pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_0].enabled = false;
mbed_official 579:53297373a894 1019 config->pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_0].pin_out = 0;
mbed_official 579:53297373a894 1020 config->pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_0].pin_mux = 0;
mbed_official 579:53297373a894 1021
mbed_official 579:53297373a894 1022 config->pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].enabled = false;
mbed_official 579:53297373a894 1023 config->pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_out = 0;
mbed_official 579:53297373a894 1024 config->pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_mux = 0;
mbed_official 579:53297373a894 1025
mbed_official 579:53297373a894 1026 config->counter_16_bit.value = 0x0000;
mbed_official 579:53297373a894 1027 config->counter_16_bit.compare_capture_channel\
mbed_official 579:53297373a894 1028 [TC_COMPARE_CAPTURE_CHANNEL_0] = 0x0000;
mbed_official 579:53297373a894 1029 config->counter_16_bit.compare_capture_channel\
mbed_official 579:53297373a894 1030 [TC_COMPARE_CAPTURE_CHANNEL_1] = 0x0000;
mbed_official 579:53297373a894 1031 #ifdef FEATURE_TC_DOUBLE_BUFFERED
mbed_official 579:53297373a894 1032 config->double_buffering_enabled = false;
mbed_official 579:53297373a894 1033 #endif
mbed_official 579:53297373a894 1034
mbed_official 579:53297373a894 1035 }
mbed_official 579:53297373a894 1036
mbed_official 579:53297373a894 1037 enum status_code tc_init(
mbed_official 579:53297373a894 1038 struct tc_module *const module_inst,
mbed_official 579:53297373a894 1039 Tc *const hw,
mbed_official 579:53297373a894 1040 const struct tc_config *const config);
mbed_official 579:53297373a894 1041
mbed_official 579:53297373a894 1042 /** @} */
mbed_official 579:53297373a894 1043
mbed_official 579:53297373a894 1044 /**
mbed_official 579:53297373a894 1045 * \name Event Management
mbed_official 579:53297373a894 1046 * @{
mbed_official 579:53297373a894 1047 */
mbed_official 579:53297373a894 1048
mbed_official 579:53297373a894 1049 /**
mbed_official 579:53297373a894 1050 * \brief Enables a TC module event input or output.
mbed_official 579:53297373a894 1051 *
mbed_official 579:53297373a894 1052 * Enables one or more input or output events to or from the TC module.
mbed_official 579:53297373a894 1053 * See \ref tc_events for a list of events this module supports.
mbed_official 579:53297373a894 1054 *
mbed_official 579:53297373a894 1055 * \note Events cannot be altered while the module is enabled.
mbed_official 579:53297373a894 1056 *
mbed_official 579:53297373a894 1057 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1058 * \param[in] events Struct containing flags of events to enable
mbed_official 579:53297373a894 1059 */
mbed_official 579:53297373a894 1060 static inline void tc_enable_events(
mbed_official 579:53297373a894 1061 struct tc_module *const module_inst,
mbed_official 579:53297373a894 1062 struct tc_events *const events)
mbed_official 579:53297373a894 1063 {
mbed_official 579:53297373a894 1064 /* Sanity check arguments */
mbed_official 579:53297373a894 1065 Assert(module_inst);
mbed_official 579:53297373a894 1066 Assert(module_inst->hw);
mbed_official 579:53297373a894 1067 Assert(events);
mbed_official 579:53297373a894 1068
mbed_official 579:53297373a894 1069 Tc *const tc_module = module_inst->hw;
mbed_official 579:53297373a894 1070
mbed_official 579:53297373a894 1071 uint32_t event_mask = 0;
mbed_official 579:53297373a894 1072
mbed_official 579:53297373a894 1073 if (events->invert_event_input == true) {
mbed_official 579:53297373a894 1074 event_mask |= TC_EVCTRL_TCINV;
mbed_official 579:53297373a894 1075 }
mbed_official 579:53297373a894 1076
mbed_official 579:53297373a894 1077 if (events->on_event_perform_action == true) {
mbed_official 579:53297373a894 1078 event_mask |= TC_EVCTRL_TCEI;
mbed_official 579:53297373a894 1079 }
mbed_official 579:53297373a894 1080
mbed_official 579:53297373a894 1081 if (events->generate_event_on_overflow == true) {
mbed_official 579:53297373a894 1082 event_mask |= TC_EVCTRL_OVFEO;
mbed_official 579:53297373a894 1083 }
mbed_official 579:53297373a894 1084
mbed_official 579:53297373a894 1085 for (uint8_t i = 0; i < NUMBER_OF_COMPARE_CAPTURE_CHANNELS; i++) {
mbed_official 579:53297373a894 1086 if (events->generate_event_on_compare_channel[i] == true) {
mbed_official 579:53297373a894 1087 event_mask |= (TC_EVCTRL_MCEO(1) << i);
mbed_official 579:53297373a894 1088 }
mbed_official 579:53297373a894 1089 }
mbed_official 579:53297373a894 1090
mbed_official 579:53297373a894 1091 tc_module->COUNT8.EVCTRL.reg |= event_mask | events->event_action;
mbed_official 579:53297373a894 1092 }
mbed_official 579:53297373a894 1093
mbed_official 579:53297373a894 1094 /**
mbed_official 579:53297373a894 1095 * \brief Disables a TC module event input or output.
mbed_official 579:53297373a894 1096 *
mbed_official 579:53297373a894 1097 * Disables one or more input or output events to or from the TC module.
mbed_official 579:53297373a894 1098 * See \ref tc_events for a list of events this module supports.
mbed_official 579:53297373a894 1099 *
mbed_official 579:53297373a894 1100 * \note Events cannot be altered while the module is enabled.
mbed_official 579:53297373a894 1101 *
mbed_official 579:53297373a894 1102 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1103 * \param[in] events Struct containing flags of events to disable
mbed_official 579:53297373a894 1104 */
mbed_official 579:53297373a894 1105 static inline void tc_disable_events(
mbed_official 579:53297373a894 1106 struct tc_module *const module_inst,
mbed_official 579:53297373a894 1107 struct tc_events *const events)
mbed_official 579:53297373a894 1108 {
mbed_official 579:53297373a894 1109 /* Sanity check arguments */
mbed_official 579:53297373a894 1110 Assert(module_inst);
mbed_official 579:53297373a894 1111 Assert(module_inst->hw);
mbed_official 579:53297373a894 1112 Assert(events);
mbed_official 579:53297373a894 1113
mbed_official 579:53297373a894 1114 Tc *const tc_module = module_inst->hw;
mbed_official 579:53297373a894 1115
mbed_official 579:53297373a894 1116 uint32_t event_mask = 0;
mbed_official 579:53297373a894 1117
mbed_official 579:53297373a894 1118 if (events->invert_event_input == true) {
mbed_official 579:53297373a894 1119 event_mask |= TC_EVCTRL_TCINV;
mbed_official 579:53297373a894 1120 }
mbed_official 579:53297373a894 1121
mbed_official 579:53297373a894 1122 if (events->on_event_perform_action == true) {
mbed_official 579:53297373a894 1123 event_mask |= TC_EVCTRL_TCEI;
mbed_official 579:53297373a894 1124 }
mbed_official 579:53297373a894 1125
mbed_official 579:53297373a894 1126 if (events->generate_event_on_overflow == true) {
mbed_official 579:53297373a894 1127 event_mask |= TC_EVCTRL_OVFEO;
mbed_official 579:53297373a894 1128 }
mbed_official 579:53297373a894 1129
mbed_official 579:53297373a894 1130 for (uint8_t i = 0; i < NUMBER_OF_COMPARE_CAPTURE_CHANNELS; i++) {
mbed_official 579:53297373a894 1131 if (events->generate_event_on_compare_channel[i] == true) {
mbed_official 579:53297373a894 1132 event_mask |= (TC_EVCTRL_MCEO(1) << i);
mbed_official 579:53297373a894 1133 }
mbed_official 579:53297373a894 1134 }
mbed_official 579:53297373a894 1135
mbed_official 579:53297373a894 1136 tc_module->COUNT8.EVCTRL.reg &= ~event_mask;
mbed_official 579:53297373a894 1137 }
mbed_official 579:53297373a894 1138
mbed_official 579:53297373a894 1139 /** @} */
mbed_official 579:53297373a894 1140
mbed_official 579:53297373a894 1141 /**
mbed_official 579:53297373a894 1142 * \name Enable/Disable/Reset
mbed_official 579:53297373a894 1143 * @{
mbed_official 579:53297373a894 1144 */
mbed_official 579:53297373a894 1145
mbed_official 579:53297373a894 1146 enum status_code tc_reset(
mbed_official 579:53297373a894 1147 const struct tc_module *const module_inst);
mbed_official 579:53297373a894 1148
mbed_official 579:53297373a894 1149 /**
mbed_official 579:53297373a894 1150 * \brief Enable the TC module.
mbed_official 579:53297373a894 1151 *
mbed_official 579:53297373a894 1152 * Enables a TC module that has been previously initialized. The counter will
mbed_official 579:53297373a894 1153 * start when the counter is enabled.
mbed_official 579:53297373a894 1154 *
mbed_official 579:53297373a894 1155 * \note When the counter is configured to re-trigger on an event, the counter
mbed_official 579:53297373a894 1156 * will not start until the start function is used.
mbed_official 579:53297373a894 1157 *
mbed_official 579:53297373a894 1158 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1159 */
mbed_official 579:53297373a894 1160 static inline void tc_enable(
mbed_official 579:53297373a894 1161 const struct tc_module *const module_inst)
mbed_official 579:53297373a894 1162 {
mbed_official 579:53297373a894 1163 /* Sanity check arguments */
mbed_official 579:53297373a894 1164 Assert(module_inst);
mbed_official 579:53297373a894 1165 Assert(module_inst->hw);
mbed_official 579:53297373a894 1166
mbed_official 579:53297373a894 1167 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1168 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1169
mbed_official 579:53297373a894 1170 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1171 /* Wait for sync */
mbed_official 579:53297373a894 1172 }
mbed_official 579:53297373a894 1173
mbed_official 579:53297373a894 1174 /* Enable TC module */
mbed_official 579:53297373a894 1175 tc_module->CTRLA.reg |= TC_CTRLA_ENABLE;
mbed_official 579:53297373a894 1176 }
mbed_official 579:53297373a894 1177
mbed_official 579:53297373a894 1178 /**
mbed_official 579:53297373a894 1179 * \brief Disables the TC module.
mbed_official 579:53297373a894 1180 *
mbed_official 579:53297373a894 1181 * Disables a TC module and stops the counter.
mbed_official 579:53297373a894 1182 *
mbed_official 579:53297373a894 1183 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1184 */
mbed_official 579:53297373a894 1185 static inline void tc_disable(
mbed_official 579:53297373a894 1186 const struct tc_module *const module_inst)
mbed_official 579:53297373a894 1187 {
mbed_official 579:53297373a894 1188 /* Sanity check arguments */
mbed_official 579:53297373a894 1189 Assert(module_inst);
mbed_official 579:53297373a894 1190 Assert(module_inst->hw);
mbed_official 579:53297373a894 1191
mbed_official 579:53297373a894 1192 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1193 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1194
mbed_official 579:53297373a894 1195 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1196 /* Wait for sync */
mbed_official 579:53297373a894 1197 }
mbed_official 579:53297373a894 1198
mbed_official 579:53297373a894 1199 /* Disable TC module */
mbed_official 579:53297373a894 1200 tc_module->CTRLA.reg &= ~TC_CTRLA_ENABLE;
mbed_official 579:53297373a894 1201 }
mbed_official 579:53297373a894 1202
mbed_official 579:53297373a894 1203 /** @} */
mbed_official 579:53297373a894 1204
mbed_official 579:53297373a894 1205 /**
mbed_official 579:53297373a894 1206 * \name Get/Set Count Value
mbed_official 579:53297373a894 1207 * @{
mbed_official 579:53297373a894 1208 */
mbed_official 579:53297373a894 1209
mbed_official 579:53297373a894 1210 uint32_t tc_get_count_value(
mbed_official 579:53297373a894 1211 const struct tc_module *const module_inst);
mbed_official 579:53297373a894 1212
mbed_official 579:53297373a894 1213 enum status_code tc_set_count_value(
mbed_official 579:53297373a894 1214 const struct tc_module *const module_inst,
mbed_official 579:53297373a894 1215 const uint32_t count);
mbed_official 579:53297373a894 1216
mbed_official 579:53297373a894 1217 /** @} */
mbed_official 579:53297373a894 1218
mbed_official 579:53297373a894 1219 /**
mbed_official 579:53297373a894 1220 * \name Start/Stop Counter
mbed_official 579:53297373a894 1221 * @{
mbed_official 579:53297373a894 1222 */
mbed_official 579:53297373a894 1223
mbed_official 579:53297373a894 1224 /**
mbed_official 579:53297373a894 1225 * \brief Stops the counter.
mbed_official 579:53297373a894 1226 *
mbed_official 579:53297373a894 1227 * This function will stop the counter. When the counter is stopped
mbed_official 579:53297373a894 1228 * the value in the count value is set to 0 if the counter was
mbed_official 579:53297373a894 1229 * counting up, or maximum if the counter was counting
mbed_official 579:53297373a894 1230 * down when stopped.
mbed_official 579:53297373a894 1231 *
mbed_official 579:53297373a894 1232 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1233 */
mbed_official 579:53297373a894 1234 static inline void tc_stop_counter(
mbed_official 579:53297373a894 1235 const struct tc_module *const module_inst)
mbed_official 579:53297373a894 1236 {
mbed_official 579:53297373a894 1237 /* Sanity check arguments */
mbed_official 579:53297373a894 1238 Assert(module_inst);
mbed_official 579:53297373a894 1239 Assert(module_inst->hw);
mbed_official 579:53297373a894 1240
mbed_official 579:53297373a894 1241 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1242 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1243
mbed_official 579:53297373a894 1244 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1245 /* Wait for sync */
mbed_official 579:53297373a894 1246 }
mbed_official 579:53297373a894 1247
mbed_official 579:53297373a894 1248 /* Write command to execute */
mbed_official 579:53297373a894 1249 tc_module->CTRLBSET.reg = TC_CTRLBSET_CMD(2);
mbed_official 579:53297373a894 1250 }
mbed_official 579:53297373a894 1251
mbed_official 579:53297373a894 1252 /**
mbed_official 579:53297373a894 1253 * \brief Starts the counter.
mbed_official 579:53297373a894 1254 *
mbed_official 579:53297373a894 1255 * Starts or restarts an initialized TC module's counter.
mbed_official 579:53297373a894 1256 *
mbed_official 579:53297373a894 1257 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1258 */
mbed_official 579:53297373a894 1259 static inline void tc_start_counter(
mbed_official 579:53297373a894 1260 const struct tc_module *const module_inst)
mbed_official 579:53297373a894 1261 {
mbed_official 579:53297373a894 1262 /* Sanity check arguments */
mbed_official 579:53297373a894 1263 Assert(module_inst);
mbed_official 579:53297373a894 1264 Assert(module_inst->hw);
mbed_official 579:53297373a894 1265
mbed_official 579:53297373a894 1266 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1267 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1268
mbed_official 579:53297373a894 1269 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1270 /* Wait for sync */
mbed_official 579:53297373a894 1271 }
mbed_official 579:53297373a894 1272
mbed_official 579:53297373a894 1273 /* Make certain that there are no conflicting commands in the register */
mbed_official 579:53297373a894 1274 tc_module->CTRLBCLR.reg = TC_CTRLBCLR_CMD_NONE;
mbed_official 579:53297373a894 1275
mbed_official 579:53297373a894 1276 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1277 /* Wait for sync */
mbed_official 579:53297373a894 1278 }
mbed_official 579:53297373a894 1279
mbed_official 579:53297373a894 1280 /* Write command to execute */
mbed_official 579:53297373a894 1281 tc_module->CTRLBSET.reg = TC_CTRLBSET_CMD(1);
mbed_official 579:53297373a894 1282 }
mbed_official 579:53297373a894 1283
mbed_official 579:53297373a894 1284 /** @} */
mbed_official 579:53297373a894 1285
mbed_official 579:53297373a894 1286 #ifdef FEATURE_TC_DOUBLE_BUFFERED
mbed_official 579:53297373a894 1287 /**
mbed_official 579:53297373a894 1288 * \name Double Buffering
mbed_official 579:53297373a894 1289 * @{
mbed_official 579:53297373a894 1290 */
mbed_official 579:53297373a894 1291
mbed_official 579:53297373a894 1292 /**
mbed_official 579:53297373a894 1293 * \brief Update double buffer.
mbed_official 579:53297373a894 1294 *
mbed_official 579:53297373a894 1295 * Update double buffer.
mbed_official 579:53297373a894 1296 *
mbed_official 579:53297373a894 1297 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1298 */
mbed_official 579:53297373a894 1299 static inline void tc_update_double_buffer(
mbed_official 579:53297373a894 1300 const struct tc_module *const module_inst)
mbed_official 579:53297373a894 1301 {
mbed_official 579:53297373a894 1302 /* Sanity check arguments */
mbed_official 579:53297373a894 1303 Assert(module_inst);
mbed_official 579:53297373a894 1304 Assert(module_inst->hw);
mbed_official 579:53297373a894 1305
mbed_official 579:53297373a894 1306 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1307 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1308
mbed_official 579:53297373a894 1309 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1310 /* Wait for sync */
mbed_official 579:53297373a894 1311 }
mbed_official 579:53297373a894 1312
mbed_official 579:53297373a894 1313 /* Make certain that there are no conflicting commands in the register */
mbed_official 579:53297373a894 1314 tc_module->CTRLBCLR.reg = TC_CTRLBCLR_CMD_NONE;
mbed_official 579:53297373a894 1315
mbed_official 579:53297373a894 1316 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1317 /* Wait for sync */
mbed_official 579:53297373a894 1318 }
mbed_official 579:53297373a894 1319
mbed_official 579:53297373a894 1320 /* Write command to execute */
mbed_official 579:53297373a894 1321 tc_module->CTRLBSET.reg = TC_CTRLBSET_CMD(3);
mbed_official 579:53297373a894 1322 }
mbed_official 579:53297373a894 1323 /** @} */
mbed_official 579:53297373a894 1324 #endif
mbed_official 579:53297373a894 1325
mbed_official 579:53297373a894 1326 #ifdef FEATURE_TC_READ_SYNC
mbed_official 579:53297373a894 1327 /**
mbed_official 579:53297373a894 1328 * \name Count Read Synchronization
mbed_official 579:53297373a894 1329 * @{
mbed_official 579:53297373a894 1330 */
mbed_official 579:53297373a894 1331
mbed_official 579:53297373a894 1332 /**
mbed_official 579:53297373a894 1333 * \brief Read synchronization of COUNT.
mbed_official 579:53297373a894 1334 *
mbed_official 579:53297373a894 1335 * Read synchronization of COUNT.
mbed_official 579:53297373a894 1336 *
mbed_official 579:53297373a894 1337 * \param[in] module_inst Pointer to the software module instance struct
mbed_official 579:53297373a894 1338 */
mbed_official 579:53297373a894 1339 static inline void tc_sync_read_count(
mbed_official 579:53297373a894 1340 const struct tc_module *const module_inst)
mbed_official 579:53297373a894 1341 {
mbed_official 579:53297373a894 1342 /* Sanity check arguments */
mbed_official 579:53297373a894 1343 Assert(module_inst);
mbed_official 579:53297373a894 1344 Assert(module_inst->hw);
mbed_official 579:53297373a894 1345
mbed_official 579:53297373a894 1346 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1347 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1348
mbed_official 579:53297373a894 1349 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1350 /* Wait for sync */
mbed_official 579:53297373a894 1351 }
mbed_official 579:53297373a894 1352
mbed_official 579:53297373a894 1353 /* Make certain that there are no conflicting commands in the register */
mbed_official 579:53297373a894 1354 tc_module->CTRLBCLR.reg = TC_CTRLBCLR_CMD_NONE;
mbed_official 579:53297373a894 1355
mbed_official 579:53297373a894 1356 while (tc_is_syncing(module_inst)) {
mbed_official 579:53297373a894 1357 /* Wait for sync */
mbed_official 579:53297373a894 1358 }
mbed_official 579:53297373a894 1359
mbed_official 579:53297373a894 1360 /* Write command to execute */
mbed_official 579:53297373a894 1361 tc_module->CTRLBSET.reg = TC_CTRLBSET_CMD(4);
mbed_official 579:53297373a894 1362 }
mbed_official 579:53297373a894 1363 /** @} */
mbed_official 579:53297373a894 1364 #endif
mbed_official 579:53297373a894 1365
mbed_official 579:53297373a894 1366 /**
mbed_official 579:53297373a894 1367 * \name Get Capture Set Compare
mbed_official 579:53297373a894 1368 * @{
mbed_official 579:53297373a894 1369 */
mbed_official 579:53297373a894 1370
mbed_official 579:53297373a894 1371 uint32_t tc_get_capture_value(
mbed_official 579:53297373a894 1372 const struct tc_module *const module_inst,
mbed_official 579:53297373a894 1373 const enum tc_compare_capture_channel channel_index);
mbed_official 579:53297373a894 1374
mbed_official 579:53297373a894 1375 enum status_code tc_set_compare_value(
mbed_official 579:53297373a894 1376 const struct tc_module *const module_inst,
mbed_official 579:53297373a894 1377 const enum tc_compare_capture_channel channel_index,
mbed_official 579:53297373a894 1378 const uint32_t compare_value);
mbed_official 579:53297373a894 1379
mbed_official 579:53297373a894 1380 /** @} */
mbed_official 579:53297373a894 1381
mbed_official 579:53297373a894 1382 /**
mbed_official 579:53297373a894 1383 * \name Set Top Value
mbed_official 579:53297373a894 1384 * @{
mbed_official 579:53297373a894 1385 */
mbed_official 579:53297373a894 1386
mbed_official 579:53297373a894 1387 enum status_code tc_set_top_value(
mbed_official 579:53297373a894 1388 const struct tc_module *const module_inst,
mbed_official 579:53297373a894 1389 const uint32_t top_value);
mbed_official 579:53297373a894 1390
mbed_official 579:53297373a894 1391 /** @} */
mbed_official 579:53297373a894 1392
mbed_official 579:53297373a894 1393 /**
mbed_official 579:53297373a894 1394 * \name Status Management
mbed_official 579:53297373a894 1395 * @{
mbed_official 579:53297373a894 1396 */
mbed_official 579:53297373a894 1397
mbed_official 579:53297373a894 1398 /**
mbed_official 579:53297373a894 1399 * \brief Retrieves the current module status.
mbed_official 579:53297373a894 1400 *
mbed_official 579:53297373a894 1401 * Retrieves the status of the module, giving overall state information.
mbed_official 579:53297373a894 1402 *
mbed_official 579:53297373a894 1403 * \param[in] module_inst Pointer to the TC software instance struct
mbed_official 579:53297373a894 1404 *
mbed_official 579:53297373a894 1405 * \return Bitmask of \c TC_STATUS_* flags.
mbed_official 579:53297373a894 1406 *
mbed_official 579:53297373a894 1407 * \retval TC_STATUS_CHANNEL_0_MATCH Timer channel 0 compare/capture match
mbed_official 579:53297373a894 1408 * \retval TC_STATUS_CHANNEL_1_MATCH Timer channel 1 compare/capture match
mbed_official 579:53297373a894 1409 * \retval TC_STATUS_SYNC_READY Timer read synchronization has completed
mbed_official 579:53297373a894 1410 * \retval TC_STATUS_CAPTURE_OVERFLOW Timer capture data has overflowed
mbed_official 579:53297373a894 1411 * \retval TC_STATUS_COUNT_OVERFLOW Timer count value has overflowed
mbed_official 579:53297373a894 1412 * \retval TC_STATUS_CHN0_BUFFER_VALID Timer count channel 0 compare/capture buffer valid
mbed_official 579:53297373a894 1413 * \retval TC_STATUS_CHN1_BUFFER_VALID Timer count channel 1 compare/capture buffer valid
mbed_official 579:53297373a894 1414 * \retval TC_STATUS_PERIOD_BUFFER_VALID Timer count period buffer valid
mbed_official 579:53297373a894 1415 */
mbed_official 579:53297373a894 1416 static inline uint32_t tc_get_status(
mbed_official 579:53297373a894 1417 struct tc_module *const module_inst)
mbed_official 579:53297373a894 1418 {
mbed_official 579:53297373a894 1419 /* Sanity check arguments */
mbed_official 579:53297373a894 1420 Assert(module_inst);
mbed_official 579:53297373a894 1421 Assert(module_inst->hw);
mbed_official 579:53297373a894 1422
mbed_official 579:53297373a894 1423 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1424 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1425
mbed_official 579:53297373a894 1426 uint32_t int_flags = tc_module->INTFLAG.reg;
mbed_official 579:53297373a894 1427
mbed_official 579:53297373a894 1428 uint32_t status_flags = 0;
mbed_official 579:53297373a894 1429
mbed_official 579:53297373a894 1430 /* Check for TC channel 0 match */
mbed_official 579:53297373a894 1431 if (int_flags & TC_INTFLAG_MC(1)) {
mbed_official 579:53297373a894 1432 status_flags |= TC_STATUS_CHANNEL_0_MATCH;
mbed_official 579:53297373a894 1433 }
mbed_official 579:53297373a894 1434
mbed_official 579:53297373a894 1435 /* Check for TC channel 1 match */
mbed_official 579:53297373a894 1436 if (int_flags & TC_INTFLAG_MC(2)) {
mbed_official 579:53297373a894 1437 status_flags |= TC_STATUS_CHANNEL_1_MATCH;
mbed_official 579:53297373a894 1438 }
mbed_official 579:53297373a894 1439
mbed_official 579:53297373a894 1440 #if !defined(FEATURE_TC_SYNCBUSY_SCHEME_VERSION_2)
mbed_official 579:53297373a894 1441 /* Check for TC read synchronization ready */
mbed_official 579:53297373a894 1442 if (int_flags & TC_INTFLAG_SYNCRDY) {
mbed_official 579:53297373a894 1443 status_flags |= TC_STATUS_SYNC_READY;
mbed_official 579:53297373a894 1444 }
mbed_official 579:53297373a894 1445 #endif
mbed_official 579:53297373a894 1446
mbed_official 579:53297373a894 1447 /* Check for TC capture overflow */
mbed_official 579:53297373a894 1448 if (int_flags & TC_INTFLAG_ERR) {
mbed_official 579:53297373a894 1449 status_flags |= TC_STATUS_CAPTURE_OVERFLOW;
mbed_official 579:53297373a894 1450 }
mbed_official 579:53297373a894 1451
mbed_official 579:53297373a894 1452 /* Check for TC count overflow */
mbed_official 579:53297373a894 1453 if (int_flags & TC_INTFLAG_OVF) {
mbed_official 579:53297373a894 1454 status_flags |= TC_STATUS_COUNT_OVERFLOW;
mbed_official 579:53297373a894 1455 }
mbed_official 579:53297373a894 1456 #ifdef FEATURE_TC_DOUBLE_BUFFERED
mbed_official 579:53297373a894 1457 uint8_t double_buffer_valid_status = tc_module->STATUS.reg;
mbed_official 579:53297373a894 1458
mbed_official 579:53297373a894 1459 /* Check channel 0 compare or capture buffer valid */
mbed_official 579:53297373a894 1460 if (double_buffer_valid_status & TC_STATUS_CCBUFV0) {
mbed_official 579:53297373a894 1461 status_flags |= TC_STATUS_CHN0_BUFFER_VALID;
mbed_official 579:53297373a894 1462 }
mbed_official 579:53297373a894 1463 /* Check channel 0 compare or capture buffer valid */
mbed_official 579:53297373a894 1464 if (double_buffer_valid_status & TC_STATUS_CCBUFV1) {
mbed_official 579:53297373a894 1465 status_flags |= TC_STATUS_CHN1_BUFFER_VALID;
mbed_official 579:53297373a894 1466 }
mbed_official 579:53297373a894 1467 /* Check period buffer valid */
mbed_official 579:53297373a894 1468 if (double_buffer_valid_status & TC_STATUS_PERBUFV) {
mbed_official 579:53297373a894 1469 status_flags |= TC_STATUS_PERIOD_BUFFER_VALID;
mbed_official 579:53297373a894 1470 }
mbed_official 579:53297373a894 1471 #endif
mbed_official 579:53297373a894 1472
mbed_official 579:53297373a894 1473 return status_flags;
mbed_official 579:53297373a894 1474 }
mbed_official 579:53297373a894 1475
mbed_official 579:53297373a894 1476 /**
mbed_official 579:53297373a894 1477 * \brief Clears a module status flag.
mbed_official 579:53297373a894 1478 *
mbed_official 579:53297373a894 1479 * Clears the given status flag of the module.
mbed_official 579:53297373a894 1480 *
mbed_official 579:53297373a894 1481 * \param[in] module_inst Pointer to the TC software instance struct
mbed_official 579:53297373a894 1482 * \param[in] status_flags Bitmask of \c TC_STATUS_* flags to clear
mbed_official 579:53297373a894 1483 */
mbed_official 579:53297373a894 1484 static inline void tc_clear_status(
mbed_official 579:53297373a894 1485 struct tc_module *const module_inst,
mbed_official 579:53297373a894 1486 const uint32_t status_flags)
mbed_official 579:53297373a894 1487 {
mbed_official 579:53297373a894 1488 /* Sanity check arguments */
mbed_official 579:53297373a894 1489 Assert(module_inst);
mbed_official 579:53297373a894 1490 Assert(module_inst->hw);
mbed_official 579:53297373a894 1491
mbed_official 579:53297373a894 1492 /* Get a pointer to the module's hardware instance */
mbed_official 579:53297373a894 1493 TcCount8 *const tc_module = &(module_inst->hw->COUNT8);
mbed_official 579:53297373a894 1494
mbed_official 579:53297373a894 1495 uint32_t int_flags = 0;
mbed_official 579:53297373a894 1496
mbed_official 579:53297373a894 1497 /* Check for TC channel 0 match */
mbed_official 579:53297373a894 1498 if (status_flags & TC_STATUS_CHANNEL_0_MATCH) {
mbed_official 579:53297373a894 1499 int_flags |= TC_INTFLAG_MC(1);
mbed_official 579:53297373a894 1500 }
mbed_official 579:53297373a894 1501
mbed_official 579:53297373a894 1502 /* Check for TC channel 1 match */
mbed_official 579:53297373a894 1503 if (status_flags & TC_STATUS_CHANNEL_1_MATCH) {
mbed_official 579:53297373a894 1504 int_flags |= TC_INTFLAG_MC(2);
mbed_official 579:53297373a894 1505 }
mbed_official 579:53297373a894 1506
mbed_official 579:53297373a894 1507 #if !defined(FEATURE_TC_SYNCBUSY_SCHEME_VERSION_2)
mbed_official 579:53297373a894 1508 /* Check for TC read synchronization ready */
mbed_official 579:53297373a894 1509 if (status_flags & TC_STATUS_SYNC_READY) {
mbed_official 579:53297373a894 1510 int_flags |= TC_INTFLAG_SYNCRDY;
mbed_official 579:53297373a894 1511 }
mbed_official 579:53297373a894 1512 #endif
mbed_official 579:53297373a894 1513
mbed_official 579:53297373a894 1514 /* Check for TC capture overflow */
mbed_official 579:53297373a894 1515 if (status_flags & TC_STATUS_CAPTURE_OVERFLOW) {
mbed_official 579:53297373a894 1516 int_flags |= TC_INTFLAG_ERR;
mbed_official 579:53297373a894 1517 }
mbed_official 579:53297373a894 1518
mbed_official 579:53297373a894 1519 /* Check for TC count overflow */
mbed_official 579:53297373a894 1520 if (status_flags & TC_STATUS_COUNT_OVERFLOW) {
mbed_official 579:53297373a894 1521 int_flags |= TC_INTFLAG_OVF;
mbed_official 579:53297373a894 1522 }
mbed_official 579:53297373a894 1523
mbed_official 579:53297373a894 1524 /* Clear interrupt flag */
mbed_official 579:53297373a894 1525 tc_module->INTFLAG.reg = int_flags;
mbed_official 579:53297373a894 1526 }
mbed_official 579:53297373a894 1527
mbed_official 579:53297373a894 1528 /** @} */
mbed_official 579:53297373a894 1529
mbed_official 579:53297373a894 1530 /** @} */
mbed_official 579:53297373a894 1531
mbed_official 579:53297373a894 1532 #ifdef __cplusplus
mbed_official 579:53297373a894 1533 }
mbed_official 579:53297373a894 1534 #endif
mbed_official 579:53297373a894 1535
mbed_official 579:53297373a894 1536 /**
mbed_official 579:53297373a894 1537 * \page asfdoc_sam0_tc_extra Extra Information for TC Driver
mbed_official 579:53297373a894 1538 *
mbed_official 579:53297373a894 1539 * \section asfdoc_sam0_tc_extra_acronyms Acronyms
mbed_official 579:53297373a894 1540 * The table below presents the acronyms used in this module:
mbed_official 579:53297373a894 1541 *
mbed_official 579:53297373a894 1542 * <table>
mbed_official 579:53297373a894 1543 * <tr>
mbed_official 579:53297373a894 1544 * <th>Acronym</th>
mbed_official 579:53297373a894 1545 * <th>Description</th>
mbed_official 579:53297373a894 1546 * </tr>
mbed_official 579:53297373a894 1547 * <tr>
mbed_official 579:53297373a894 1548 * <td>DMA</td>
mbed_official 579:53297373a894 1549 * <td>Direct Memory Access</td>
mbed_official 579:53297373a894 1550 * </tr>
mbed_official 579:53297373a894 1551 * <tr>
mbed_official 579:53297373a894 1552 * <td>TC</td>
mbed_official 579:53297373a894 1553 * <td>Timer Counter</td>
mbed_official 579:53297373a894 1554 * </tr>
mbed_official 579:53297373a894 1555 * <tr>
mbed_official 579:53297373a894 1556 * <td>PWM</td>
mbed_official 579:53297373a894 1557 * <td>Pulse Width Modulation</td>
mbed_official 579:53297373a894 1558 * </tr>
mbed_official 579:53297373a894 1559 * <tr>
mbed_official 579:53297373a894 1560 * <td>PWP</td>
mbed_official 579:53297373a894 1561 * <td>Pulse Width Period</td>
mbed_official 579:53297373a894 1562 * </tr>
mbed_official 579:53297373a894 1563 * <tr>
mbed_official 579:53297373a894 1564 * <td>PPW</td>
mbed_official 579:53297373a894 1565 * <td>Period Pulse Width</td>
mbed_official 579:53297373a894 1566 * </tr>
mbed_official 579:53297373a894 1567 * </table>
mbed_official 579:53297373a894 1568 *
mbed_official 579:53297373a894 1569 *
mbed_official 579:53297373a894 1570 * \section asfdoc_sam0_tc_extra_dependencies Dependencies
mbed_official 579:53297373a894 1571 * This driver has the following dependencies:
mbed_official 579:53297373a894 1572 *
mbed_official 579:53297373a894 1573 * - \ref asfdoc_sam0_system_pinmux_group "System Pin Multiplexer Driver"
mbed_official 579:53297373a894 1574 *
mbed_official 579:53297373a894 1575 *
mbed_official 579:53297373a894 1576 * \section asfdoc_sam0_tc_extra_errata Errata
mbed_official 579:53297373a894 1577 * There are no errata related to this driver.
mbed_official 579:53297373a894 1578 *
mbed_official 579:53297373a894 1579 *
mbed_official 579:53297373a894 1580 * \section asfdoc_sam0_tc_extra_history Module History
mbed_official 579:53297373a894 1581 * An overview of the module history is presented in the table below, with
mbed_official 579:53297373a894 1582 * details on the enhancements and fixes made to the module since its first
mbed_official 579:53297373a894 1583 * release. The current version of this corresponds to the newest version in
mbed_official 579:53297373a894 1584 * the table.
mbed_official 579:53297373a894 1585 *
mbed_official 579:53297373a894 1586 * <table>
mbed_official 579:53297373a894 1587 * <tr>
mbed_official 579:53297373a894 1588 * <th>Changelog</th>
mbed_official 579:53297373a894 1589 * </tr>
mbed_official 579:53297373a894 1590 * <tr>
mbed_official 579:53297373a894 1591 * <td>Added support for SAML21</td>
mbed_official 579:53297373a894 1592 * </tr>
mbed_official 579:53297373a894 1593 * <tr>
mbed_official 579:53297373a894 1594 * <td>Added support for SAMD10/D11</td>
mbed_official 579:53297373a894 1595 * </tr>
mbed_official 579:53297373a894 1596 * <tr>
mbed_official 579:53297373a894 1597 * <td>Added support for SAMR21</td>
mbed_official 579:53297373a894 1598 * </tr>
mbed_official 579:53297373a894 1599 * <tr>
mbed_official 579:53297373a894 1600 * <td>Added support for SAMD21 and do some modifications as below:
mbed_official 579:53297373a894 1601 * \li Clean up in the configuration structure, the counter size
mbed_official 579:53297373a894 1602 * setting specific registers is accessed through the counter_8_bit,
mbed_official 579:53297373a894 1603 * counter_16_bit and counter_32_bit structures
mbed_official 579:53297373a894 1604 * \li All event related settings moved into the tc_event structure </td>
mbed_official 579:53297373a894 1605 * </tr>
mbed_official 579:53297373a894 1606 * <tr>
mbed_official 579:53297373a894 1607 * <td>Added automatic digital clock interface enable for the slave TC
mbed_official 579:53297373a894 1608 * module when a timer is initialized in 32-bit mode</td>
mbed_official 579:53297373a894 1609 * </tr>
mbed_official 579:53297373a894 1610 * <tr>
mbed_official 579:53297373a894 1611 * <td>Initial Release</td>
mbed_official 579:53297373a894 1612 * </tr>
mbed_official 579:53297373a894 1613 * </table>
mbed_official 579:53297373a894 1614 */
mbed_official 579:53297373a894 1615
mbed_official 579:53297373a894 1616 /**
mbed_official 579:53297373a894 1617 * \page asfdoc_sam0_tc_exqsg Examples for TC Driver
mbed_official 579:53297373a894 1618 *
mbed_official 579:53297373a894 1619 * This is a list of the available Quick Start guides (QSGs) and example
mbed_official 579:53297373a894 1620 * applications for \ref asfdoc_sam0_tc_group. QSGs are simple examples with
mbed_official 579:53297373a894 1621 * step-by-step instructions to configure and use this driver in a selection of
mbed_official 579:53297373a894 1622 * use cases. Note that QSGs can be compiled as a standalone application or be
mbed_official 579:53297373a894 1623 * added to the user application.
mbed_official 579:53297373a894 1624 *
mbed_official 579:53297373a894 1625 * - \subpage asfdoc_sam0_tc_basic_use_case
mbed_official 579:53297373a894 1626 * \if TC_CALLBACK_MODE
mbed_official 579:53297373a894 1627 * - \subpage asfdoc_sam0_tc_timer_use_case
mbed_official 579:53297373a894 1628 * - \subpage asfdoc_sam0_tc_callback_use_case
mbed_official 579:53297373a894 1629 * \endif
mbed_official 579:53297373a894 1630 * - \subpage asfdoc_sam0_tc_dma_use_case
mbed_official 579:53297373a894 1631 *
mbed_official 579:53297373a894 1632 * \page asfdoc_sam0_tc_document_revision_history Document Revision History
mbed_official 579:53297373a894 1633 *
mbed_official 579:53297373a894 1634 * <table>
mbed_official 579:53297373a894 1635 * <tr>
mbed_official 579:53297373a894 1636 * <th>Doc. Rev.</td>
mbed_official 579:53297373a894 1637 * <th>Date</td>
mbed_official 579:53297373a894 1638 * <th>Comments</td>
mbed_official 579:53297373a894 1639 * </tr>
mbed_official 579:53297373a894 1640 * <tr>
mbed_official 579:53297373a894 1641 * <td>E</td>
mbed_official 579:53297373a894 1642 * <td>11/2014</td>
mbed_official 579:53297373a894 1643 * <td>Added support for SAML21.</td>
mbed_official 579:53297373a894 1644 * </tr>
mbed_official 579:53297373a894 1645 * <tr>
mbed_official 579:53297373a894 1646 * <td>D</td>
mbed_official 579:53297373a894 1647 * <td>12/2014</td>
mbed_official 579:53297373a894 1648 * <td>Added timer use case.
mbed_official 579:53297373a894 1649 * Added support for SAMR21 and SAMD10/D11.</td>
mbed_official 579:53297373a894 1650 * </tr>
mbed_official 579:53297373a894 1651 * <tr>
mbed_official 579:53297373a894 1652 * <td>C</td>
mbed_official 579:53297373a894 1653 * <td>01/2014</td>
mbed_official 579:53297373a894 1654 * <td>Added support for SAMD21.</td>
mbed_official 579:53297373a894 1655 * </tr>
mbed_official 579:53297373a894 1656 * <tr>
mbed_official 579:53297373a894 1657 * <td>B</td>
mbed_official 579:53297373a894 1658 * <td>06/2013</td>
mbed_official 579:53297373a894 1659 * <td>Corrected documentation typos.</td>
mbed_official 579:53297373a894 1660 * </tr>
mbed_official 579:53297373a894 1661 * <tr>
mbed_official 579:53297373a894 1662 * <td>A</td>
mbed_official 579:53297373a894 1663 * <td>06/2013</td>
mbed_official 579:53297373a894 1664 * <td>Initial release</td>
mbed_official 579:53297373a894 1665 * </tr>
mbed_official 579:53297373a894 1666 * </table>
mbed_official 579:53297373a894 1667 */
mbed_official 579:53297373a894 1668
mbed_official 579:53297373a894 1669 #endif /* TC_H_INCLUDED */