git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_MSP432_LaunchPad_IAR_CCS_Keil/driverlib/timer_a.c

   1 /*
   2  * -------------------------------------------
   3  *    MSP432 DriverLib - v01_04_00_18
   4  * -------------------------------------------
   5  *
   6  * --COPYRIGHT--,BSD,BSD
   7  * Copyright (c) 2015, Texas Instruments Incorporated
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * *  Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  *
  17  * *  Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * *  Neither the name of Texas Instruments Incorporated nor the names of
  22  *    its contributors may be used to endorse or promote products derived
  23  *    from this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  35  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  * --/COPYRIGHT--*/
  37 #include <timer_a.h>
  38 #include <interrupt.h>
  39 #include <debug.h>
  40
  41 static void privateTimer_AProcessClockSourceDivider(uint32_t timer,
  42         uint16_t clockSourceDivider)
  43 {
  44     TIMER_A_CMSIS(timer)->rCTL.r &= ~ID__8;
  45     TIMER_A_CMSIS(timer)->rEX0.r &= ~TAIDEX_7;
  46
  47     switch (clockSourceDivider)
  48     {
  49     case TIMER_A_CLOCKSOURCE_DIVIDER_1:
  50     case TIMER_A_CLOCKSOURCE_DIVIDER_2:
  51         TIMER_A_CMSIS(timer)->rCTL.r |= ((clockSourceDivider - 1) << 6);
  52         TIMER_A_CMSIS(timer)->rEX0.r = TAIDEX_0;
  53         break;
  54     case TIMER_A_CLOCKSOURCE_DIVIDER_4:
  55         TIMER_A_CMSIS(timer)->rCTL.r |= ID__4;
  56         TIMER_A_CMSIS(timer)->rEX0.r = TAIDEX_0;
  57         break;
  58     case TIMER_A_CLOCKSOURCE_DIVIDER_8:
  59         TIMER_A_CMSIS(timer)->rCTL.r |= ID__8;
  60         TIMER_A_CMSIS(timer)->rEX0.r = TAIDEX_0;
  61         break;
  62     case TIMER_A_CLOCKSOURCE_DIVIDER_3:
  63     case TIMER_A_CLOCKSOURCE_DIVIDER_5:
  64     case TIMER_A_CLOCKSOURCE_DIVIDER_6:
  65     case TIMER_A_CLOCKSOURCE_DIVIDER_7:
  66         TIMER_A_CMSIS(timer)->rCTL.r |= ID__1;
  67         TIMER_A_CMSIS(timer)->rEX0.r = (clockSourceDivider - 1);
  68         break;
  69
  70     case TIMER_A_CLOCKSOURCE_DIVIDER_10:
  71     case TIMER_A_CLOCKSOURCE_DIVIDER_12:
  72     case TIMER_A_CLOCKSOURCE_DIVIDER_14:
  73     case TIMER_A_CLOCKSOURCE_DIVIDER_16:
  74         TIMER_A_CMSIS(timer)->rCTL.r |= ID__2;
  75         TIMER_A_CMSIS(timer)->rEX0.r = (clockSourceDivider / 2 - 1);
  76         break;
  77
  78     case TIMER_A_CLOCKSOURCE_DIVIDER_20:
  79     case TIMER_A_CLOCKSOURCE_DIVIDER_24:
  80     case TIMER_A_CLOCKSOURCE_DIVIDER_28:
  81     case TIMER_A_CLOCKSOURCE_DIVIDER_32:
  82         TIMER_A_CMSIS(timer)->rCTL.r |= ID__4;
  83         TIMER_A_CMSIS(timer)->rEX0.r = (clockSourceDivider / 4 - 1);
  84         break;
  85     case TIMER_A_CLOCKSOURCE_DIVIDER_40:
  86     case TIMER_A_CLOCKSOURCE_DIVIDER_48:
  87     case TIMER_A_CLOCKSOURCE_DIVIDER_56:
  88     case TIMER_A_CLOCKSOURCE_DIVIDER_64:
  89         TIMER_A_CMSIS(timer)->rCTL.r |= ID__8;
  90         TIMER_A_CMSIS(timer)->rEX0.r = (clockSourceDivider / 8 - 1);
  91         break;
  92     }
  93 }
  94
  95 void Timer_A_startCounter(uint32_t timer, uint_fast16_t timerMode)
  96 {
  97     ASSERT(
  98             (TIMER_A_UPDOWN_MODE == timerMode)
  99             || (TIMER_A_CONTINUOUS_MODE == timerMode)
 100             || (TIMER_A_UP_MODE == timerMode));
 101
 102     TIMER_A_CMSIS(timer)->rCTL.r |= timerMode;
 103 }
 104
 105 void Timer_A_configureContinuousMode(uint32_t timer,
 106         const Timer_A_ContinuousModeConfig *config)
 107 {
 108     ASSERT(
 109             (TIMER_A_CLOCKSOURCE_EXTERNAL_TXCLK == config->clockSource)
 110             || (TIMER_A_CLOCKSOURCE_ACLK == config->clockSource)
 111             || (TIMER_A_CLOCKSOURCE_SMCLK == config->clockSource)
 112             || (TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK
 113                     == config->clockSource));
 114
 115     ASSERT(
 116             (TIMER_A_DO_CLEAR == config->timerClear)
 117             || (TIMER_A_SKIP_CLEAR == config->timerClear));
 118
 119     ASSERT(
 120             (TIMER_A_TAIE_INTERRUPT_ENABLE == config->timerInterruptEnable_TAIE)
 121             || (TIMER_A_TAIE_INTERRUPT_DISABLE
 122                     == config->timerInterruptEnable_TAIE));
 123
 124     ASSERT(
 125             (TIMER_A_CLOCKSOURCE_DIVIDER_1 == config->clockSourceDivider)
 126             || (TIMER_A_CLOCKSOURCE_DIVIDER_2
 127                     == config->clockSourceDivider)
 128             || (TIMER_A_CLOCKSOURCE_DIVIDER_4
 129                     == config->clockSourceDivider)
 130             || (TIMER_A_CLOCKSOURCE_DIVIDER_8
 131                     == config->clockSourceDivider)
 132             || (TIMER_A_CLOCKSOURCE_DIVIDER_3
 133                     == config->clockSourceDivider)
 134             || (TIMER_A_CLOCKSOURCE_DIVIDER_5
 135                     == config->clockSourceDivider)
 136             || (TIMER_A_CLOCKSOURCE_DIVIDER_6
 137                     == config->clockSourceDivider)
 138             || (TIMER_A_CLOCKSOURCE_DIVIDER_7
 139                     == config->clockSourceDivider)
 140             || (TIMER_A_CLOCKSOURCE_DIVIDER_10
 141                     == config->clockSourceDivider)
 142             || (TIMER_A_CLOCKSOURCE_DIVIDER_12
 143                     == config->clockSourceDivider)
 144             || (TIMER_A_CLOCKSOURCE_DIVIDER_14
 145                     == config->clockSourceDivider)
 146             || (TIMER_A_CLOCKSOURCE_DIVIDER_16
 147                     == config->clockSourceDivider)
 148             || (TIMER_A_CLOCKSOURCE_DIVIDER_20
 149                     == config->clockSourceDivider)
 150             || (TIMER_A_CLOCKSOURCE_DIVIDER_24
 151                     == config->clockSourceDivider)
 152             || (TIMER_A_CLOCKSOURCE_DIVIDER_28
 153                     == config->clockSourceDivider)
 154             || (TIMER_A_CLOCKSOURCE_DIVIDER_32
 155                     == config->clockSourceDivider)
 156             || (TIMER_A_CLOCKSOURCE_DIVIDER_40
 157                     == config->clockSourceDivider)
 158             || (TIMER_A_CLOCKSOURCE_DIVIDER_48
 159                     == config->clockSourceDivider)
 160             || (TIMER_A_CLOCKSOURCE_DIVIDER_56
 161                     == config->clockSourceDivider)
 162             || (TIMER_A_CLOCKSOURCE_DIVIDER_64
 163                     == config->clockSourceDivider));
 164
 165     privateTimer_AProcessClockSourceDivider(timer, config->clockSourceDivider);
 166
 167     TIMER_A_CMSIS(timer)->rCTL.r = (TIMER_A_CMSIS(timer)->rCTL.r
 168             & ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK
 169                     + TIMER_A_UPDOWN_MODE + TIMER_A_DO_CLEAR
 170                     + TIMER_A_TAIE_INTERRUPT_ENABLE))
 171             | (config->clockSource + config->timerClear
 172                     + config->timerInterruptEnable_TAIE);
 173 }
 174
 175 void Timer_A_configureUpMode(uint32_t timer, const Timer_A_UpModeConfig *config)
 176 {
 177     ASSERT(
 178             (TIMER_A_CLOCKSOURCE_EXTERNAL_TXCLK == config->clockSource)
 179             || (TIMER_A_CLOCKSOURCE_ACLK == config->clockSource)
 180             || (TIMER_A_CLOCKSOURCE_SMCLK == config->clockSource)
 181             || (TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK
 182                     == config->clockSource));
 183
 184     ASSERT(
 185             (TIMER_A_DO_CLEAR == config->timerClear)
 186             || (TIMER_A_SKIP_CLEAR == config->timerClear));
 187
 188     ASSERT(
 189             (TIMER_A_DO_CLEAR == config->timerClear)
 190             || (TIMER_A_SKIP_CLEAR == config->timerClear));
 191
 192     privateTimer_AProcessClockSourceDivider(timer, config->clockSourceDivider);
 193
 194     TIMER_A_CMSIS(timer)->rCTL.r &=
 195             ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK + TIMER_A_UPDOWN_MODE
 196                     + TIMER_A_DO_CLEAR + TIMER_A_TAIE_INTERRUPT_ENABLE);
 197
 198     TIMER_A_CMSIS(timer)->rCTL.r |= (config->clockSource + config->timerClear
 199             + config->timerInterruptEnable_TAIE);
 200
 201     if (TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE
 202             == config->captureCompareInterruptEnable_CCR0_CCIE)
 203         BITBAND_PERI(TIMER_A_CMSIS(timer)->rCCTL0.r,CCIE_OFS) = 1;
 204     else
 205         BITBAND_PERI(TIMER_A_CMSIS(timer)->rCCTL0.r,CCIE_OFS) = 0;
 206
 207     TIMER_A_CMSIS(timer)->rCCR0 = config->timerPeriod;
 208 }
 209
 210 void Timer_A_configureUpDownMode(uint32_t timer,
 211         const Timer_A_UpDownModeConfig *config)
 212 {
 213     ASSERT(
 214             (TIMER_A_CLOCKSOURCE_EXTERNAL_TXCLK == config->clockSource)
 215             || (TIMER_A_CLOCKSOURCE_ACLK == config->clockSource)
 216             || (TIMER_A_CLOCKSOURCE_SMCLK == config->clockSource)
 217             || (TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK
 218                     == config->clockSource));
 219
 220     ASSERT(
 221             (TIMER_A_DO_CLEAR == config->timerClear)
 222             || (TIMER_A_SKIP_CLEAR == config->timerClear));
 223
 224     ASSERT(
 225             (TIMER_A_DO_CLEAR == config->timerClear)
 226             || (TIMER_A_SKIP_CLEAR == config->timerClear));
 227
 228     privateTimer_AProcessClockSourceDivider(timer, config->clockSourceDivider);
 229
 230     TIMER_A_CMSIS(timer)->rCTL.r &=
 231             ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK + TIMER_A_UPDOWN_MODE
 232                     + TIMER_A_DO_CLEAR + TIMER_A_TAIE_INTERRUPT_ENABLE);
 233
 234     TIMER_A_CMSIS(timer)->rCTL.r |= (config->clockSource + TIMER_A_STOP_MODE
 235             + config->timerClear + config->timerInterruptEnable_TAIE);
 236     if (TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE
 237             == config->captureCompareInterruptEnable_CCR0_CCIE)
 238         BITBAND_PERI(TIMER_A_CMSIS(timer)->rCCTL0.r,CCIE_OFS) = 1;
 239     else
 240         BITBAND_PERI(TIMER_A_CMSIS(timer)->rCCTL0.r,CCIE_OFS) = 0;
 241
 242     TIMER_A_CMSIS(timer)->rCCR0 = config->timerPeriod;
 243 }
 244
 245 void Timer_A_initCapture(uint32_t timer,
 246         const Timer_A_CaptureModeConfig *config)
 247 {
 248     ASSERT(
 249             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == config->captureRegister)
 250             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 251                     == config->captureRegister)
 252             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 253                     == config->captureRegister)
 254             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 255                     == config->captureRegister)
 256             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 257                     == config->captureRegister)
 258             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 259                     == config->captureRegister)
 260             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 261                     == config->captureRegister));
 262
 263     ASSERT(
 264             (TIMER_A_CAPTUREMODE_NO_CAPTURE == config->captureMode)
 265             || (TIMER_A_CAPTUREMODE_RISING_EDGE == config->captureMode)
 266             || (TIMER_A_CAPTUREMODE_FALLING_EDGE == config->captureMode)
 267             || (TIMER_A_CAPTUREMODE_RISING_AND_FALLING_EDGE
 268                     == config->captureMode));
 269
 270     ASSERT(
 271             (TIMER_A_CAPTURE_INPUTSELECT_CCIxA == config->captureInputSelect)
 272             || (TIMER_A_CAPTURE_INPUTSELECT_CCIxB
 273                     == config->captureInputSelect)
 274             || (TIMER_A_CAPTURE_INPUTSELECT_GND
 275                     == config->captureInputSelect)
 276             || (TIMER_A_CAPTURE_INPUTSELECT_Vcc
 277                     == config->captureInputSelect));
 278
 279     ASSERT(
 280             (TIMER_A_CAPTURE_ASYNCHRONOUS == config->synchronizeCaptureSource)
 281             || (TIMER_A_CAPTURE_SYNCHRONOUS
 282                     == config->synchronizeCaptureSource));
 283
 284     ASSERT(
 285             (TIMER_A_CAPTURECOMPARE_INTERRUPT_DISABLE
 286                     == config->captureInterruptEnable)
 287             || (TIMER_A_CAPTURECOMPARE_INTERRUPT_ENABLE
 288                     == config->captureInterruptEnable));
 289
 290     ASSERT(
 291             (TIMER_A_OUTPUTMODE_OUTBITVALUE == config->captureOutputMode)
 292             || (TIMER_A_OUTPUTMODE_SET == config->captureOutputMode)
 293             || (TIMER_A_OUTPUTMODE_TOGGLE_RESET
 294                     == config->captureOutputMode)
 295             || (TIMER_A_OUTPUTMODE_SET_RESET
 296                     == config->captureOutputMode)
 297             || (TIMER_A_OUTPUTMODE_TOGGLE == config->captureOutputMode)
 298             || (TIMER_A_OUTPUTMODE_RESET == config->captureOutputMode)
 299             || (TIMER_A_OUTPUTMODE_TOGGLE_SET
 300                     == config->captureOutputMode)
 301             || (TIMER_A_OUTPUTMODE_RESET_SET
 302                     == config->captureOutputMode));
 303
 304     if (TIMER_A_CAPTURECOMPARE_REGISTER_0 == config->captureRegister)
 305     {
 306         //CaptureCompare register 0 only supports certain modes
 307         ASSERT(
 308                 (TIMER_A_OUTPUTMODE_OUTBITVALUE == config->captureOutputMode)
 309                 || (TIMER_A_OUTPUTMODE_SET == config->captureOutputMode)
 310                 || (TIMER_A_OUTPUTMODE_TOGGLE
 311                         == config->captureOutputMode)
 312                 || (TIMER_A_OUTPUTMODE_RESET
 313                         == config->captureOutputMode));
 314     }
 315
 316     HWREG16(timer + config->captureRegister) =
 317             (HWREG16(timer + config->captureRegister)
 318                     & ~(TIMER_A_CAPTUREMODE_RISING_AND_FALLING_EDGE
 319                             | TIMER_A_CAPTURE_INPUTSELECT_Vcc
 320                             | TIMER_A_CAPTURE_SYNCHRONOUS | TIMER_A_DO_CLEAR
 321                             | TIMER_A_TAIE_INTERRUPT_ENABLE | CM_3))
 322                     | (config->captureMode | config->captureInputSelect
 323                             | config->synchronizeCaptureSource
 324                             | config->captureInterruptEnable
 325                             | config->captureOutputMode | CAP);
 326 }
 327
 328 void Timer_A_initCompare(uint32_t timer,
 329         const Timer_A_CompareModeConfig *config)
 330 {
 331     ASSERT(
 332             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == config->compareRegister)
 333             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 334                     == config->compareRegister)
 335             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 336                     == config->compareRegister)
 337             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 338                     == config->compareRegister)
 339             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 340                     == config->compareRegister)
 341             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 342                     == config->compareRegister)
 343             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 344                     == config->compareRegister));
 345
 346     ASSERT(
 347             (TIMER_A_CAPTURECOMPARE_INTERRUPT_ENABLE
 348                     == config->compareInterruptEnable)
 349             || (TIMER_A_CAPTURECOMPARE_INTERRUPT_DISABLE
 350                     == config->compareInterruptEnable));
 351
 352     ASSERT(
 353             (TIMER_A_OUTPUTMODE_OUTBITVALUE == config->compareOutputMode)
 354             || (TIMER_A_OUTPUTMODE_SET == config->compareOutputMode)
 355             || (TIMER_A_OUTPUTMODE_TOGGLE_RESET
 356                     == config->compareOutputMode)
 357             || (TIMER_A_OUTPUTMODE_SET_RESET
 358                     == config->compareOutputMode)
 359             || (TIMER_A_OUTPUTMODE_TOGGLE == config->compareOutputMode)
 360             || (TIMER_A_OUTPUTMODE_RESET == config->compareOutputMode)
 361             || (TIMER_A_OUTPUTMODE_TOGGLE_SET
 362                     == config->compareOutputMode)
 363             || (TIMER_A_OUTPUTMODE_RESET_SET
 364                     == config->compareOutputMode));
 365
 366     if (TIMER_A_CAPTURECOMPARE_REGISTER_0 == config->compareRegister)
 367     {
 368         //CaptureCompare register 0 only supports certain modes
 369         ASSERT(
 370                 (TIMER_A_OUTPUTMODE_OUTBITVALUE == config->compareOutputMode)
 371                 || (TIMER_A_OUTPUTMODE_SET == config->compareOutputMode)
 372                 || (TIMER_A_OUTPUTMODE_TOGGLE
 373                         == config->compareOutputMode)
 374                 || (TIMER_A_OUTPUTMODE_RESET
 375                         == config->compareOutputMode));
 376     }
 377
 378     HWREG16(timer + config->compareRegister) =
 379             (HWREG16(timer + config->compareRegister)
 380                     & ~(TIMER_A_CAPTURECOMPARE_INTERRUPT_ENABLE
 381                             | TIMER_A_OUTPUTMODE_RESET_SET | CAP))
 382                     | (config->compareInterruptEnable
 383                             + config->compareOutputMode);
 384
 385     HWREG16(timer + config->compareRegister + OFS_TA0R) = config->compareValue;
 386 }
 387
 388 uint16_t Timer_A_getCounterValue(uint32_t timer)
 389 {
 390     uint16_t voteOne, voteTwo, res;
 391
 392     voteTwo = TIMER_A_CMSIS(timer)->rR;
 393
 394     do
 395     {
 396         voteOne = voteTwo;
 397         voteTwo = TIMER_A_CMSIS(timer)->rR;
 398
 399         if (voteTwo > voteOne)
 400             res = voteTwo - voteOne;
 401         else if (voteOne > voteTwo)
 402             res = voteOne - voteTwo;
 403         else
 404             res = 0;
 405
 406     } while (res > TIMER_A_THRESHOLD);
 407
 408     return voteTwo;
 409
 410 }
 411
 412 void Timer_A_clearTimer(uint32_t timer)
 413 {
 414     BITBAND_PERI(TIMER_A_CMSIS(timer)->rCTL.r , TACLR_OFS) = 1;
 415 }
 416
 417 uint_fast8_t Timer_A_getSynchronizedCaptureCompareInput(uint32_t timer,
 418         uint_fast16_t captureCompareRegister, uint_fast16_t synchronizedSetting)
 419 {
 420     ASSERT(
 421             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == captureCompareRegister)
 422             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 423                     == captureCompareRegister)
 424             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 425                     == captureCompareRegister)
 426             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 427                     == captureCompareRegister)
 428             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 429                     == captureCompareRegister)
 430             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 431                     == captureCompareRegister)
 432             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 433                     == captureCompareRegister));
 434
 435     ASSERT(
 436             (TIMER_A_READ_CAPTURE_COMPARE_INPUT == synchronizedSetting)
 437             || (TIMER_A_READ_SYNCHRONIZED_CAPTURECOMPAREINPUT
 438                     == synchronizedSetting));
 439
 440     if (HWREG16(timer + captureCompareRegister) & synchronizedSetting)
 441         return TIMER_A_CAPTURECOMPARE_INPUT_HIGH;
 442     else
 443         return TIMER_A_CAPTURECOMPARE_INPUT_LOW;
 444 }
 445
 446 uint_fast8_t Timer_A_getOutputForOutputModeOutBitValue(uint32_t timer,
 447         uint_fast16_t captureCompareRegister)
 448 {
 449     ASSERT(
 450             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == captureCompareRegister)
 451             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 452                     == captureCompareRegister)
 453             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 454                     == captureCompareRegister)
 455             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 456                     == captureCompareRegister)
 457             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 458                     == captureCompareRegister)
 459             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 460                     == captureCompareRegister)
 461             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 462                     == captureCompareRegister));
 463
 464     if (HWREGBIT16(timer + captureCompareRegister, OUT_OFS))
 465         return TIMER_A_OUTPUTMODE_OUTBITVALUE_HIGH;
 466     else
 467         return TIMER_A_OUTPUTMODE_OUTBITVALUE_LOW;
 468 }
 469
 470 uint_fast16_t Timer_A_getCaptureCompareCount(uint32_t timer,
 471         uint_fast16_t captureCompareRegister)
 472 {
 473     ASSERT(
 474             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == captureCompareRegister)
 475             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 476                     == captureCompareRegister)
 477             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 478                     == captureCompareRegister)
 479             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 480                     == captureCompareRegister)
 481             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 482                     == captureCompareRegister)
 483             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 484                     == captureCompareRegister)
 485             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 486                     == captureCompareRegister));
 487
 488     return HWREG16(timer + OFS_TA0R + captureCompareRegister);
 489 }
 490
 491 void Timer_A_setOutputForOutputModeOutBitValue(uint32_t timer,
 492         uint_fast16_t captureCompareRegister,
 493         uint_fast8_t outputModeOutBitValue)
 494 {
 495     TIMER_A_setOutputForOutputModeOutBitValue(timer, captureCompareRegister,
 496             outputModeOutBitValue);
 497 }
 498
 499 void Timer_A_generatePWM(uint32_t timer, const Timer_A_PWMConfig *config)
 500 {
 501     ASSERT(
 502             (TIMER_A_CLOCKSOURCE_EXTERNAL_TXCLK == config->clockSource)
 503             || (TIMER_A_CLOCKSOURCE_ACLK == config->clockSource)
 504             || (TIMER_A_CLOCKSOURCE_SMCLK == config->clockSource)
 505             || (TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK
 506                     == config->clockSource));
 507
 508     ASSERT(
 509             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == config->compareRegister)
 510             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 511                     == config->compareRegister)
 512             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 513                     == config->compareRegister)
 514             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 515                     == config->compareRegister)
 516             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 517                     == config->compareRegister)
 518             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 519                     == config->compareRegister)
 520             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 521                     == config->compareRegister));
 522
 523     ASSERT(
 524             (TIMER_A_OUTPUTMODE_OUTBITVALUE == config->compareOutputMode)
 525             || (TIMER_A_OUTPUTMODE_SET == config->compareOutputMode)
 526             || (TIMER_A_OUTPUTMODE_TOGGLE_RESET
 527                     == config->compareOutputMode)
 528             || (TIMER_A_OUTPUTMODE_SET_RESET
 529                     == config->compareOutputMode)
 530             || (TIMER_A_OUTPUTMODE_TOGGLE == config->compareOutputMode)
 531             || (TIMER_A_OUTPUTMODE_RESET == config->compareOutputMode)
 532             || (TIMER_A_OUTPUTMODE_TOGGLE_SET
 533                     == config->compareOutputMode)
 534             || (TIMER_A_OUTPUTMODE_RESET_SET
 535                     == config->compareOutputMode));
 536
 537     privateTimer_AProcessClockSourceDivider(timer, config->clockSourceDivider);
 538
 539     TIMER_A_CMSIS(timer)->rCTL.r &=
 540             ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK + TIMER_A_UPDOWN_MODE
 541                     + TIMER_A_DO_CLEAR + TIMER_A_TAIE_INTERRUPT_ENABLE);
 542
 543     TIMER_A_CMSIS(timer)->rCTL.r |= (config->clockSource + TIMER_A_UP_MODE
 544             + TIMER_A_DO_CLEAR);
 545
 546     TIMER_A_CMSIS(timer)->rCCR0 = config->timerPeriod;
 547
 548     HWREG16(timer + OFS_TA0CCTL0) &= ~(TIMER_A_CAPTURECOMPARE_INTERRUPT_ENABLE
 549             + TIMER_A_OUTPUTMODE_RESET_SET);
 550     HWREG16(timer + config->compareRegister) |= config->compareOutputMode;
 551
 552     HWREG16(timer + config->compareRegister + OFS_TA0R) = config->dutyCycle;
 553 }
 554
 555 void Timer_A_stopTimer(uint32_t timer)
 556 {
 557     TIMER_A_CMSIS(timer)->rCTL.r &= ~MC_3;
 558 }
 559
 560 void Timer_A_setCompareValue(uint32_t timer, uint_fast16_t compareRegister,
 561         uint_fast16_t compareValue)
 562 {
 563     ASSERT(
 564             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == compareRegister)
 565             || (TIMER_A_CAPTURECOMPARE_REGISTER_1 == compareRegister)
 566             || (TIMER_A_CAPTURECOMPARE_REGISTER_2 == compareRegister)
 567             || (TIMER_A_CAPTURECOMPARE_REGISTER_3 == compareRegister)
 568             || (TIMER_A_CAPTURECOMPARE_REGISTER_4 == compareRegister)
 569             || (TIMER_A_CAPTURECOMPARE_REGISTER_5 == compareRegister)
 570             || (TIMER_A_CAPTURECOMPARE_REGISTER_6 == compareRegister));
 571
 572     HWREG16(timer + compareRegister + OFS_TA0R) = compareValue;
 573 }
 574
 575 void Timer_A_clearInterruptFlag(uint32_t timer)
 576 {
 577     BITBAND_PERI(TIMER_A_CMSIS(timer)->rCTL.r,TAIFG_OFS) = 0;
 578 }
 579
 580 void Timer_A_clearCaptureCompareInterrupt(uint32_t timer,
 581         uint_fast16_t captureCompareRegister)
 582 {
 583     ASSERT(
 584             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == captureCompareRegister)
 585             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 586                     == captureCompareRegister)
 587             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 588                     == captureCompareRegister)
 589             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 590                     == captureCompareRegister)
 591             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 592                     == captureCompareRegister)
 593             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 594                     == captureCompareRegister)
 595             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 596                     == captureCompareRegister));
 597
 598     HWREGBIT16(timer + captureCompareRegister, CCIFG_OFS) = 0;
 599 }
 600
 601 void Timer_A_enableInterrupt(uint32_t timer)
 602 {
 603     BITBAND_PERI(TIMER_A_CMSIS(timer)->rCTL.r,TAIE_OFS) = 1;
 604 }
 605
 606 void Timer_A_disableInterrupt(uint32_t timer)
 607 {
 608     BITBAND_PERI(TIMER_A_CMSIS(timer)->rCTL.r,TAIE_OFS) = 0;
 609 }
 610
 611 uint32_t Timer_A_getInterruptStatus(uint32_t timer)
 612 {
 613     return TIMER_A_CMSIS(timer)->rCTL.b.bIFG;
 614 }
 615
 616 void Timer_A_enableCaptureCompareInterrupt(uint32_t timer,
 617         uint_fast16_t captureCompareRegister)
 618 {
 619     ASSERT(
 620             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == captureCompareRegister)
 621             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 622                     == captureCompareRegister)
 623             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 624                     == captureCompareRegister)
 625             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 626                     == captureCompareRegister)
 627             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 628                     == captureCompareRegister)
 629             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 630                     == captureCompareRegister)
 631             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 632                     == captureCompareRegister));
 633
 634     HWREGBIT16(timer + captureCompareRegister, CCIE_OFS) = 1;
 635 }
 636
 637 void Timer_A_disableCaptureCompareInterrupt(uint32_t timer,
 638         uint_fast16_t captureCompareRegister)
 639 {
 640     ASSERT(
 641             (TIMER_A_CAPTURECOMPARE_REGISTER_0 == captureCompareRegister)
 642             || (TIMER_A_CAPTURECOMPARE_REGISTER_1
 643                     == captureCompareRegister)
 644             || (TIMER_A_CAPTURECOMPARE_REGISTER_2
 645                     == captureCompareRegister)
 646             || (TIMER_A_CAPTURECOMPARE_REGISTER_3
 647                     == captureCompareRegister)
 648             || (TIMER_A_CAPTURECOMPARE_REGISTER_4
 649                     == captureCompareRegister)
 650             || (TIMER_A_CAPTURECOMPARE_REGISTER_5
 651                     == captureCompareRegister)
 652             || (TIMER_A_CAPTURECOMPARE_REGISTER_6
 653                     == captureCompareRegister));
 654
 655     HWREGBIT16(timer + captureCompareRegister, CCIE_OFS) = 0;
 656 }
 657
 658 uint32_t Timer_A_getCaptureCompareInterruptStatus(uint32_t timer,
 659         uint_fast16_t captureCompareRegister, uint_fast16_t mask)
 660 {
 661     return HWREG16(timer + captureCompareRegister) & mask;
 662 }
 663
 664 uint32_t Timer_A_getEnabledInterruptStatus(uint32_t timer)
 665 {
 666     if (TIMER_A_CMSIS(timer)->rCTL.r & TAIE)
 667     {
 668         return Timer_A_getInterruptStatus(timer);
 669     } else
 670     {
 671         return 0;
 672     }
 673
 674 }
 675
 676 uint32_t Timer_A_getCaptureCompareEnabledInterruptStatus(uint32_t timer,
 677         uint_fast16_t captureCompareRegister)
 678 {
 679     if (HWREGBIT16(timer + captureCompareRegister, CCIE_OFS))
 680         return Timer_A_getCaptureCompareInterruptStatus(timer,
 681                 captureCompareRegister,
 682                 TIMER_A_CAPTURE_OVERFLOW |
 683                 TIMER_A_CAPTURECOMPARE_INTERRUPT_FLAG);
 684     else
 685         return 0;
 686 }
 687
 688 void Timer_A_registerInterrupt(uint32_t timer, uint_fast8_t interruptSelect,
 689         void (*intHandler)(void))
 690 {
 691     if (interruptSelect == TIMER_A_CCR0_INTERRUPT)
 692     {
 693         switch (timer)
 694         {
 695         case TIMER_A0_MODULE:
 696             Interrupt_registerInterrupt(INT_TA0_0, intHandler);
 697             Interrupt_enableInterrupt(INT_TA0_0);
 698             break;
 699         case TIMER_A1_MODULE:
 700             Interrupt_registerInterrupt(INT_TA1_0, intHandler);
 701             Interrupt_enableInterrupt(INT_TA1_0);
 702             break;
 703         case TIMER_A2_MODULE:
 704             Interrupt_registerInterrupt(INT_TA2_0, intHandler);
 705             Interrupt_enableInterrupt(INT_TA2_0);
 706             break;
 707         case TIMER_A3_MODULE:
 708             Interrupt_registerInterrupt(INT_TA3_0, intHandler);
 709             Interrupt_enableInterrupt(INT_TA3_0);
 710             break;
 711         default:
 712             ASSERT(false);
 713         }
 714     } else if (interruptSelect == TIMER_A_CCRX_AND_OVERFLOW_INTERRUPT)
 715     {
 716         switch (timer)
 717         {
 718         case TIMER_A0_MODULE:
 719             Interrupt_registerInterrupt(INT_TA0_N, intHandler);
 720             Interrupt_enableInterrupt(INT_TA0_N);
 721             break;
 722         case TIMER_A1_MODULE:
 723             Interrupt_registerInterrupt(INT_TA1_N, intHandler);
 724             Interrupt_enableInterrupt(INT_TA1_N);
 725             break;
 726         case TIMER_A2_MODULE:
 727             Interrupt_registerInterrupt(INT_TA2_N, intHandler);
 728             Interrupt_enableInterrupt(INT_TA2_N);
 729             break;
 730         case TIMER_A3_MODULE:
 731             Interrupt_registerInterrupt(INT_TA3_N, intHandler);
 732             Interrupt_enableInterrupt(INT_TA3_N);
 733             break;
 734         default:
 735             ASSERT(false);
 736         }
 737     } else
 738     {
 739         ASSERT(false);
 740     }
 741 }
 742
 743 void Timer_A_unregisterInterrupt(uint32_t timer, uint_fast8_t interruptSelect)
 744 {
 745     if (interruptSelect == TIMER_A_CCR0_INTERRUPT)
 746     {
 747         switch (timer)
 748         {
 749         case TIMER_A0_MODULE:
 750             Interrupt_disableInterrupt(INT_TA0_0);
 751             Interrupt_unregisterInterrupt(INT_TA0_0);
 752             break;
 753         case TIMER_A1_MODULE:
 754             Interrupt_disableInterrupt(INT_TA1_0);
 755             Interrupt_unregisterInterrupt(INT_TA1_0);
 756             break;
 757         case TIMER_A2_MODULE:
 758             Interrupt_disableInterrupt(INT_TA2_0);
 759             Interrupt_unregisterInterrupt(INT_TA2_0);
 760             break;
 761         case TIMER_A3_MODULE:
 762             Interrupt_disableInterrupt(INT_TA3_0);
 763             Interrupt_unregisterInterrupt(INT_TA3_0);
 764             break;
 765         default:
 766             ASSERT(false);
 767         }
 768     } else if (interruptSelect == TIMER_A_CCRX_AND_OVERFLOW_INTERRUPT)
 769     {
 770         switch (timer)
 771         {
 772         case TIMER_A0_MODULE:
 773             Interrupt_disableInterrupt(INT_TA0_N);
 774             Interrupt_unregisterInterrupt(INT_TA0_N);
 775             break;
 776         case TIMER_A1_MODULE:
 777             Interrupt_disableInterrupt(INT_TA1_N);
 778             Interrupt_unregisterInterrupt(INT_TA1_N);
 779             break;
 780         case TIMER_A2_MODULE:
 781             Interrupt_disableInterrupt(INT_TA2_N);
 782             Interrupt_unregisterInterrupt(INT_TA2_N);
 783             break;
 784         case TIMER_A3_MODULE:
 785             Interrupt_disableInterrupt(INT_TA3_N);
 786             Interrupt_unregisterInterrupt(INT_TA3_N);
 787             break;
 788         default:
 789             ASSERT(false);
 790         }
 791     } else
 792     {
 793         ASSERT(false);
 794     }
 795 }
 796