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

   1 /* --COPYRIGHT--,BSD\r
   2  * Copyright (c) 2014, Texas Instruments Incorporated\r
   3  * All rights reserved.\r
   4  *\r
   5  * Redistribution and use in source and binary forms, with or without\r
   6  * modification, are permitted provided that the following conditions\r
   7  * are met:\r
   8  *\r
   9  * *  Redistributions of source code must retain the above copyright\r
  10  *    notice, this list of conditions and the following disclaimer.\r
  11  *\r
  12  * *  Redistributions in binary form must reproduce the above copyright\r
  13  *    notice, this list of conditions and the following disclaimer in the\r
  14  *    documentation and/or other materials provided with the distribution.\r
  15  *\r
  16  * *  Neither the name of Texas Instruments Incorporated nor the names of\r
  17  *    its contributors may be used to endorse or promote products derived\r
  18  *    from this software without specific prior written permission.\r
  19  *\r
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,\r
  22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
  23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\r
  24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
  25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
  26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
  27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
  28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
  29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\r
  30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  31  * --/COPYRIGHT--*/\r
  32 //*****************************************************************************\r
  33 //\r
  34 // timer_a.c - Driver for the timer_a Module.\r
  35 //\r
  36 //*****************************************************************************\r
  37 \r
  38 //*****************************************************************************\r
  39 //\r
  40 //! \addtogroup timer_a_api timer_a\r
  41 //! @{\r
  42 //\r
  43 //*****************************************************************************\r
  44 \r
  45 #include "inc/hw_regaccess.h"\r
  46 #include "inc/hw_memmap.h"\r
  47 \r
  48 #ifdef __MSP430_HAS_TxA7__\r
  49 #include "timer_a.h"\r
  50 \r
  51 #include <assert.h>\r
  52 \r
  53 void Timer_A_startCounter(uint16_t baseAddress,\r
  54                           uint16_t timerMode)\r
  55 {\r
  56     HWREG16(baseAddress + OFS_TAxCTL) |= timerMode;\r
  57 }\r
  58 \r
  59 void Timer_A_initContinuousMode(uint16_t baseAddress,\r
  60                                 Timer_A_initContinuousModeParam *param)\r
  61 {\r
  62     HWREG16(baseAddress +\r
  63             OFS_TAxCTL) &= ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK +\r
  64                              TIMER_A_UPDOWN_MODE +\r
  65                              TIMER_A_DO_CLEAR +\r
  66                              TIMER_A_TAIE_INTERRUPT_ENABLE +\r
  67                              ID__8\r
  68                              );\r
  69     HWREG16(baseAddress + OFS_TAxEX0) &= ~TAIDEX_7;\r
  70 \r
  71     HWREG16(baseAddress + OFS_TAxEX0) |= param->clockSourceDivider & 0x7;\r
  72     HWREG16(baseAddress + OFS_TAxCTL) |= (param->clockSource +\r
  73                                           param->timerClear +\r
  74                                           param->timerInterruptEnable_TAIE +\r
  75                                           ((param->clockSourceDivider >>\r
  76                                             3) << 6));\r
  77 \r
  78     if(param->startTimer)\r
  79     {\r
  80         HWREG16(baseAddress + OFS_TAxCTL) |= TIMER_A_CONTINUOUS_MODE;\r
  81     }\r
  82 }\r
  83 \r
  84 void Timer_A_initUpMode(uint16_t baseAddress,\r
  85                         Timer_A_initUpModeParam *param)\r
  86 {\r
  87     HWREG16(baseAddress + OFS_TAxCTL) &=\r
  88         ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK +\r
  89           TIMER_A_UPDOWN_MODE +\r
  90           TIMER_A_DO_CLEAR +\r
  91           TIMER_A_TAIE_INTERRUPT_ENABLE +\r
  92           ID__8\r
  93           );\r
  94     HWREG16(baseAddress + OFS_TAxEX0) &= ~TAIDEX_7;\r
  95 \r
  96     HWREG16(baseAddress + OFS_TAxEX0) |= param->clockSourceDivider & 0x7;\r
  97     HWREG16(baseAddress + OFS_TAxCTL) |= (param->clockSource +\r
  98                                           param->timerClear +\r
  99                                           param->timerInterruptEnable_TAIE +\r
 100                                           ((param->clockSourceDivider >>\r
 101                                             3) << 6));\r
 102 \r
 103     if(param->startTimer)\r
 104     {\r
 105         HWREG16(baseAddress + OFS_TAxCTL) |= TIMER_A_UP_MODE;\r
 106     }\r
 107 \r
 108     if(TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE ==\r
 109        param->captureCompareInterruptEnable_CCR0_CCIE)\r
 110     {\r
 111         HWREG16(baseAddress +\r
 112                 OFS_TAxCCTL0) |= TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE;\r
 113     }\r
 114     else\r
 115     {\r
 116         HWREG16(baseAddress +\r
 117                 OFS_TAxCCTL0) &= ~TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE;\r
 118     }\r
 119 \r
 120     HWREG16(baseAddress + OFS_TAxCCR0) = param->timerPeriod;\r
 121 }\r
 122 \r
 123 void Timer_A_initUpDownMode(uint16_t baseAddress,\r
 124                             Timer_A_initUpDownModeParam *param)\r
 125 {\r
 126     HWREG16(baseAddress + OFS_TAxCTL) &=\r
 127         ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK +\r
 128           TIMER_A_UPDOWN_MODE +\r
 129           TIMER_A_DO_CLEAR +\r
 130           TIMER_A_TAIE_INTERRUPT_ENABLE +\r
 131           ID__8\r
 132           );\r
 133     HWREG16(baseAddress + OFS_TAxEX0) &= ~TAIDEX_7;\r
 134 \r
 135     HWREG16(baseAddress + OFS_TAxEX0) |= param->clockSourceDivider & 0x7;\r
 136     HWREG16(baseAddress + OFS_TAxCTL) |= (param->clockSource +\r
 137                                           param->timerClear +\r
 138                                           param->timerInterruptEnable_TAIE +\r
 139                                           ((param->clockSourceDivider >>\r
 140                                             3) << 6));\r
 141 \r
 142     if(param->startTimer)\r
 143     {\r
 144         HWREG16(baseAddress + OFS_TAxCTL) |= TIMER_A_UPDOWN_MODE;\r
 145     }\r
 146 \r
 147     if(TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE ==\r
 148        param->captureCompareInterruptEnable_CCR0_CCIE)\r
 149     {\r
 150         HWREG16(baseAddress +\r
 151                 OFS_TAxCCTL0) |= TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE;\r
 152     }\r
 153     else\r
 154     {\r
 155         HWREG16(baseAddress +\r
 156                 OFS_TAxCCTL0) &= ~TIMER_A_CCIE_CCR0_INTERRUPT_ENABLE;\r
 157     }\r
 158 \r
 159     HWREG16(baseAddress + OFS_TAxCCR0) = param->timerPeriod;\r
 160 }\r
 161 \r
 162 void Timer_A_initCaptureMode(uint16_t baseAddress,\r
 163                              Timer_A_initCaptureModeParam *param)\r
 164 {\r
 165     HWREG16(baseAddress + param->captureRegister) |= CAP;\r
 166 \r
 167     HWREG16(baseAddress + param->captureRegister) &=\r
 168         ~(TIMER_A_CAPTUREMODE_RISING_AND_FALLING_EDGE +\r
 169           TIMER_A_CAPTURE_INPUTSELECT_Vcc +\r
 170           TIMER_A_CAPTURE_SYNCHRONOUS +\r
 171           TIMER_A_DO_CLEAR +\r
 172           TIMER_A_TAIE_INTERRUPT_ENABLE +\r
 173           CM_3\r
 174           );\r
 175 \r
 176     HWREG16(baseAddress + param->captureRegister) |= (param->captureMode +\r
 177                                                       param->captureInputSelect\r
 178                                                       +\r
 179                                                       param->\r
 180                                                       synchronizeCaptureSource +\r
 181                                                       param->\r
 182                                                       captureInterruptEnable +\r
 183                                                       param->captureOutputMode\r
 184                                                       );\r
 185 }\r
 186 \r
 187 void Timer_A_initCompareMode(uint16_t baseAddress,\r
 188                              Timer_A_initCompareModeParam *param)\r
 189 {\r
 190     HWREG16(baseAddress + param->compareRegister) &= ~CAP;\r
 191 \r
 192     HWREG16(baseAddress + param->compareRegister) &=\r
 193         ~(TIMER_A_CAPTURECOMPARE_INTERRUPT_ENABLE +\r
 194           TIMER_A_OUTPUTMODE_RESET_SET\r
 195           );\r
 196 \r
 197     HWREG16(baseAddress +\r
 198             param->compareRegister) |= (param->compareInterruptEnable +\r
 199                                         param->compareOutputMode\r
 200                                         );\r
 201 \r
 202     HWREG16(baseAddress + param->compareRegister +\r
 203             OFS_TAxR) = param->compareValue;\r
 204 }\r
 205 \r
 206 void Timer_A_enableInterrupt(uint16_t baseAddress)\r
 207 {\r
 208     HWREG16(baseAddress + OFS_TAxCTL) |= TAIE;\r
 209 }\r
 210 \r
 211 void Timer_A_disableInterrupt(uint16_t baseAddress)\r
 212 {\r
 213     HWREG16(baseAddress + OFS_TAxCTL) &= ~TAIE;\r
 214 }\r
 215 \r
 216 uint32_t Timer_A_getInterruptStatus(uint16_t baseAddress)\r
 217 {\r
 218     return (HWREG16(baseAddress + OFS_TAxCTL) & TAIFG);\r
 219 }\r
 220 \r
 221 void Timer_A_enableCaptureCompareInterrupt(uint16_t baseAddress,\r
 222                                            uint16_t captureCompareRegister)\r
 223 {\r
 224     HWREG16(baseAddress + captureCompareRegister) |= CCIE;\r
 225 }\r
 226 \r
 227 void Timer_A_disableCaptureCompareInterrupt(uint16_t baseAddress,\r
 228                                             uint16_t captureCompareRegister)\r
 229 {\r
 230     HWREG16(baseAddress + captureCompareRegister) &= ~CCIE;\r
 231 }\r
 232 \r
 233 uint32_t Timer_A_getCaptureCompareInterruptStatus(uint16_t baseAddress,\r
 234                                                   uint16_t captureCompareRegister,\r
 235                                                   uint16_t mask)\r
 236 {\r
 237     return (HWREG16(baseAddress + captureCompareRegister) & mask);\r
 238 }\r
 239 \r
 240 void Timer_A_clear(uint16_t baseAddress)\r
 241 {\r
 242     HWREG16(baseAddress + OFS_TAxCTL) |= TACLR;\r
 243 }\r
 244 \r
 245 uint8_t Timer_A_getSynchronizedCaptureCompareInput(uint16_t baseAddress,\r
 246                                                    uint16_t captureCompareRegister,\r
 247                                                    uint16_t synchronized)\r
 248 {\r
 249     if(HWREG16(baseAddress + captureCompareRegister) & synchronized)\r
 250     {\r
 251         return (TIMER_A_CAPTURECOMPARE_INPUT_HIGH);\r
 252     }\r
 253     else\r
 254     {\r
 255         return (TIMER_A_CAPTURECOMPARE_INPUT_LOW);\r
 256     }\r
 257 }\r
 258 \r
 259 uint8_t Timer_A_getOutputForOutputModeOutBitValue(uint16_t baseAddress,\r
 260                                                   uint16_t captureCompareRegister)\r
 261 {\r
 262     if(HWREG16(baseAddress + captureCompareRegister) & OUT)\r
 263     {\r
 264         return (TIMER_A_OUTPUTMODE_OUTBITVALUE_HIGH);\r
 265     }\r
 266     else\r
 267     {\r
 268         return (TIMER_A_OUTPUTMODE_OUTBITVALUE_LOW);\r
 269     }\r
 270 }\r
 271 \r
 272 uint16_t Timer_A_getCaptureCompareCount(uint16_t baseAddress,\r
 273                                         uint16_t captureCompareRegister)\r
 274 {\r
 275     return  (HWREG16(baseAddress + OFS_TAxR + captureCompareRegister));\r
 276 }\r
 277 \r
 278 void Timer_A_setOutputForOutputModeOutBitValue(uint16_t baseAddress,\r
 279                                                uint16_t captureCompareRegister,\r
 280                                                uint8_t outputModeOutBitValue)\r
 281 {\r
 282     HWREG16(baseAddress + captureCompareRegister) &= ~OUT;\r
 283     HWREG16(baseAddress + captureCompareRegister) |= outputModeOutBitValue;\r
 284 }\r
 285 \r
 286 void Timer_A_outputPWM(uint16_t baseAddress,\r
 287                        Timer_A_outputPWMParam *param)\r
 288 {\r
 289     HWREG16(baseAddress + OFS_TAxCTL) &=\r
 290         ~(TIMER_A_CLOCKSOURCE_INVERTED_EXTERNAL_TXCLK +\r
 291           TIMER_A_UPDOWN_MODE + TIMER_A_DO_CLEAR +\r
 292           TIMER_A_TAIE_INTERRUPT_ENABLE +\r
 293           ID__8\r
 294           );\r
 295     HWREG16(baseAddress + OFS_TAxEX0) &= ~TAIDEX_7;\r
 296 \r
 297     HWREG16(baseAddress + OFS_TAxEX0) |= param->clockSourceDivider & 0x7;\r
 298     HWREG16(baseAddress + OFS_TAxCTL) |= (param->clockSource +\r
 299                                           TIMER_A_UP_MODE +\r
 300                                           TIMER_A_DO_CLEAR +\r
 301                                           ((param->clockSourceDivider >>\r
 302                                             3) << 6));\r
 303 \r
 304     HWREG16(baseAddress + OFS_TAxCCR0) = param->timerPeriod;\r
 305 \r
 306     HWREG16(baseAddress + OFS_TAxCCTL0) &=\r
 307         ~(TIMER_A_CAPTURECOMPARE_INTERRUPT_ENABLE +\r
 308           TIMER_A_OUTPUTMODE_RESET_SET);\r
 309 \r
 310     HWREG16(baseAddress + param->compareRegister) |= param->compareOutputMode;\r
 311 \r
 312     HWREG16(baseAddress + param->compareRegister + OFS_TAxR) = param->dutyCycle;\r
 313 }\r
 314 \r
 315 void Timer_A_stop(uint16_t baseAddress)\r
 316 {\r
 317     HWREG16(baseAddress + OFS_TAxCTL) &= ~MC_3;\r
 318 }\r
 319 \r
 320 void Timer_A_setCompareValue(uint16_t baseAddress,\r
 321                              uint16_t compareRegister,\r
 322                              uint16_t compareValue)\r
 323 {\r
 324     HWREG16(baseAddress + compareRegister + OFS_TAxR) = compareValue;\r
 325 }\r
 326 \r
 327 void Timer_A_clearTimerInterrupt(uint16_t baseAddress)\r
 328 {\r
 329     HWREG16(baseAddress + OFS_TAxCTL) &= ~TAIFG;\r
 330 }\r
 331 \r
 332 void Timer_A_clearCaptureCompareInterrupt(uint16_t baseAddress,\r
 333                                           uint16_t captureCompareRegister)\r
 334 {\r
 335     HWREG16(baseAddress + captureCompareRegister) &= ~CCIFG;\r
 336 }\r
 337 \r
 338 uint16_t Timer_A_getCounterValue(uint16_t baseAddress)\r
 339 {\r
 340     uint16_t voteOne, voteTwo, res;\r
 341 \r
 342     voteTwo = HWREG16(baseAddress + OFS_TAxR);\r
 343 \r
 344     do\r
 345     {\r
 346         voteOne = voteTwo;\r
 347         voteTwo = HWREG16(baseAddress + OFS_TAxR);\r
 348 \r
 349         if(voteTwo > voteOne)\r
 350         {\r
 351             res = voteTwo - voteOne;\r
 352         }\r
 353         else if(voteOne > voteTwo)\r
 354         {\r
 355             res = voteOne - voteTwo;\r
 356         }\r
 357         else\r
 358         {\r
 359             res = 0;\r
 360         }\r
 361     }\r
 362     while(res > TIMER_A_THRESHOLD);\r
 363 \r
 364     return(voteTwo);\r
 365 }\r
 366 \r
 367 #endif\r
 368 //*****************************************************************************\r
 369 //\r
 370 //! Close the doxygen group for timer_a_api\r
 371 //! @}\r
 372 //\r
 373 //*****************************************************************************\r