git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_MSP432_LaunchPad_IAR_CCS_Keil/driverlib/adc14.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 /* Standard Includes */
  38 #include <stdint.h>
  39 #include <stdbool.h>
  40
  41 /* DriverLib Includes */
  42 #include <adc14.h>
  43 #include <debug.h>
  44 #include <interrupt.h>
  45
  46 /* Statics */
  47 static volatile uint32_t* const _ctlRegs[32] =
  48 { &ADC14->rMCTL0.r, &ADC14->rMCTL1.r, &ADC14->rMCTL2.r, &ADC14->rMCTL3.r,
  49         &ADC14->rMCTL4.r, &ADC14->rMCTL5.r, &ADC14->rMCTL6.r, &ADC14->rMCTL7.r,
  50         &ADC14->rMCTL8.r, &ADC14->rMCTL9.r, &ADC14->rMCTL10.r,
  51         &ADC14->rMCTL11.r, &ADC14->rMCTL12.r, &ADC14->rMCTL13.r,
  52         &ADC14->rMCTL14.r, &ADC14->rMCTL15.r, &ADC14->rMCTL16.r,
  53         &ADC14->rMCTL17.r, &ADC14->rMCTL18.r, &ADC14->rMCTL19.r,
  54         &ADC14->rMCTL20.r, &ADC14->rMCTL21.r, &ADC14->rMCTL22.r,
  55         &ADC14->rMCTL23.r, &ADC14->rMCTL24.r, &ADC14->rMCTL25.r,
  56         &ADC14->rMCTL26.r, &ADC14->rMCTL27.r, &ADC14->rMCTL28.r,
  57         &ADC14->rMCTL29.r, &ADC14->rMCTL30.r, &ADC14->rMCTL31.r };
  58
  59 static uint_fast8_t _getIndexForMemRegister(uint32_t reg)
  60 {
  61     switch (reg)
  62     {
  63     case ADC_MEM0:
  64         return 0;
  65     case ADC_MEM1:
  66         return 1;
  67     case ADC_MEM2:
  68         return 2;
  69     case ADC_MEM3:
  70         return 3;
  71     case ADC_MEM4:
  72         return 4;
  73     case ADC_MEM5:
  74         return 5;
  75     case ADC_MEM6:
  76         return 6;
  77     case ADC_MEM7:
  78         return 7;
  79     case ADC_MEM8:
  80         return 8;
  81     case ADC_MEM9:
  82         return 9;
  83     case ADC_MEM10:
  84         return 10;
  85     case ADC_MEM11:
  86         return 11;
  87     case ADC_MEM12:
  88         return 12;
  89     case ADC_MEM13:
  90         return 13;
  91     case ADC_MEM14:
  92         return 14;
  93     case ADC_MEM15:
  94         return 15;
  95     case ADC_MEM16:
  96         return 16;
  97     case ADC_MEM17:
  98         return 17;
  99     case ADC_MEM18:
 100         return 18;
 101     case ADC_MEM19:
 102         return 19;
 103     case ADC_MEM20:
 104         return 20;
 105     case ADC_MEM21:
 106         return 21;
 107     case ADC_MEM22:
 108         return 22;
 109     case ADC_MEM23:
 110         return 23;
 111     case ADC_MEM24:
 112         return 24;
 113     case ADC_MEM25:
 114         return 25;
 115     case ADC_MEM26:
 116         return 26;
 117     case ADC_MEM27:
 118         return 27;
 119     case ADC_MEM28:
 120         return 28;
 121     case ADC_MEM29:
 122         return 29;
 123     case ADC_MEM30:
 124         return 30;
 125     case ADC_MEM31:
 126         return 31;
 127     default:
 128         ASSERT(false);
 129         return ADC_INVALID_MEM;
 130
 131     }
 132 }
 133
 134 //*****************************************************************************
 135 //
 136 //!
 137 //! Returns a boolean value that tells if conversion is active/running or is
 138 //! not acMSP432 ted.
 139 //!
 140 //! Originally a public function, but moved to static. External customers should
 141 //! use the ADC14_isBusy function.
 142 //!
 143 //! \return true if conversion is active, false otherwise
 144 //
 145 //*****************************************************************************
 146 static bool ADCIsConversionRunning(void)
 147 {
 148     return BITBAND_PERI(ADC14->rCTL0.r, ADC14BUSY_OFS);
 149 }
 150
 151 void ADC14_enableModule(void)
 152 {
 153     BITBAND_PERI(ADC14->rCTL0.r, ADC14ON_OFS) = 1;
 154 }
 155
 156 bool ADC14_disableModule(void)
 157 {
 158     if (ADCIsConversionRunning())
 159         return false;
 160
 161     BITBAND_PERI(ADC14->rCTL0.r, ADC14ON_OFS) = 0;
 162
 163     return true;
 164 }
 165
 166 bool ADC14_enableSampleTimer(uint32_t multiSampleConvert)
 167 {
 168     if (ADCIsConversionRunning())
 169         return false;
 170
 171     BITBAND_PERI(ADC14->rCTL0.r, ADC14SHP_OFS) = 1;
 172
 173     if (multiSampleConvert == ADC_MANUAL_ITERATION)
 174     {
 175         BITBAND_PERI(ADC14->rCTL0.r, ADC14MSC_OFS) = 0;
 176     } else
 177     {
 178         BITBAND_PERI(ADC14->rCTL0.r, ADC14MSC_OFS) = 1;
 179     }
 180
 181     return true;
 182 }
 183
 184 bool ADC14_disableSampleTimer(void)
 185 {
 186     if (ADCIsConversionRunning())
 187         return false;
 188
 189     BITBAND_PERI(ADC14->rCTL0.r, ADC14SHP_OFS) = 0;
 190
 191     return true;
 192 }
 193
 194 bool ADC14_initModule(uint32_t clockSource, uint32_t clockPredivider,
 195         uint32_t clockDivider, uint32_t internalChannelMask)
 196 {
 197     ASSERT(
 198             clockSource == ADC_CLOCKSOURCE_ADCOSC
 199             || clockSource == ADC_CLOCKSOURCE_SYSOSC
 200             || clockSource == ADC_CLOCKSOURCE_ACLK
 201             || clockSource == ADC_CLOCKSOURCE_MCLK
 202             || clockSource == ADC_CLOCKSOURCE_SMCLK
 203             || clockSource == ADC_CLOCKSOURCE_HSMCLK);
 204
 205     ASSERT(
 206             clockPredivider == ADC_PREDIVIDER_1
 207             || clockPredivider == ADC_PREDIVIDER_4
 208             || clockPredivider == ADC_PREDIVIDER_32
 209             || clockPredivider == ADC_PREDIVIDER_64);
 210
 211     ASSERT(
 212             clockDivider == ADC_DIVIDER_1 || clockDivider == ADC_DIVIDER_2
 213             || clockDivider == ADC_DIVIDER_3
 214             || clockDivider == ADC_DIVIDER_4
 215             || clockDivider == ADC_DIVIDER_5
 216             || clockDivider == ADC_DIVIDER_6
 217             || clockDivider == ADC_DIVIDER_7
 218             || clockDivider == ADC_DIVIDER_8);
 219
 220     ASSERT(
 221             !(internalChannelMask
 222                     & ~(ADC_MAPINTCH3 | ADC_MAPINTCH2 | ADC_MAPINTCH1
 223                             | ADC_MAPINTCH0 | ADC_TEMPSENSEMAP | ADC_BATTMAP)));
 224
 225     if (ADCIsConversionRunning())
 226         return false;
 227
 228     ADC14->rCTL0.r = (ADC14->rCTL0.r
 229             & ~(ADC14PDIV_M | ADC14DIV_M | ADC14SSEL_M))
 230             | clockDivider | clockPredivider | clockSource;
 231
 232     ADC14->rCTL1.r = (ADC14->rCTL1.r
 233             & ~(ADC_MAPINTCH3 | ADC_MAPINTCH2 | ADC_MAPINTCH1 | ADC_MAPINTCH0
 234                     | ADC_TEMPSENSEMAP | ADC_BATTMAP)) | internalChannelMask;
 235
 236     return true;
 237 }
 238
 239 void ADC14_setResolution(uint32_t resolution)
 240 {
 241     ASSERT(
 242             resolution == ADC_8BIT || resolution == ADC_10BIT
 243             || resolution == ADC_12BIT || resolution == ADC_14BIT);
 244
 245     ADC14->rCTL1.r = (ADC14->rCTL1.r & ~ADC14RES_M) |  resolution;
 246 }
 247
 248 uint_fast32_t ADC14_getResolution(void)
 249 {
 250     return ADC14->rCTL1.r & ADC14RES_M;
 251 }
 252
 253 bool ADC14_setSampleHoldTrigger(uint32_t source, bool invertSignal)
 254 {
 255
 256     ASSERT(
 257             source == ADC_TRIGGER_ADCSC || source == ADC_TRIGGER_SOURCE1
 258             || source == ADC_TRIGGER_SOURCE2
 259             || source == ADC_TRIGGER_SOURCE3
 260             || source == ADC_TRIGGER_SOURCE4
 261             || source == ADC_TRIGGER_SOURCE5
 262             || source == ADC_TRIGGER_SOURCE6
 263             || source == ADC_TRIGGER_SOURCE7);
 264
 265     if (ADCIsConversionRunning())
 266         return false;
 267
 268     if (invertSignal)
 269     {
 270         ADC14->rCTL0.r = (ADC14->rCTL0.r
 271                 & ~(ADC14ISSH | ADC14SHS_M)) | source
 272                 | ADC14ISSH;
 273     } else
 274     {
 275         ADC14->rCTL0.r = (ADC14->rCTL0.r
 276                 & ~(ADC14ISSH | ADC14SHS_M)) | source;
 277     }
 278
 279     return true;
 280 }
 281
 282 bool ADC14_setSampleHoldTime(uint32_t firstPulseWidth,
 283         uint32_t secondPulseWidth)
 284 {
 285     ASSERT(
 286             firstPulseWidth == ADC_PULSE_WIDTH_4
 287             || firstPulseWidth == ADC_PULSE_WIDTH_8
 288             || firstPulseWidth == ADC_PULSE_WIDTH_16
 289             || firstPulseWidth == ADC_PULSE_WIDTH_32
 290             || firstPulseWidth == ADC_PULSE_WIDTH_64
 291             || firstPulseWidth == ADC_PULSE_WIDTH_96
 292             || firstPulseWidth == ADC_PULSE_WIDTH_128
 293             || firstPulseWidth == ADC_PULSE_WIDTH_192);
 294
 295     ASSERT(
 296             secondPulseWidth == ADC_PULSE_WIDTH_4
 297             || secondPulseWidth == ADC_PULSE_WIDTH_8
 298             || secondPulseWidth == ADC_PULSE_WIDTH_16
 299             || secondPulseWidth == ADC_PULSE_WIDTH_32
 300             || secondPulseWidth == ADC_PULSE_WIDTH_64
 301             || secondPulseWidth == ADC_PULSE_WIDTH_96
 302             || secondPulseWidth == ADC_PULSE_WIDTH_128
 303             || secondPulseWidth == ADC_PULSE_WIDTH_192);
 304
 305     if (ADCIsConversionRunning())
 306         return false;
 307
 308     ADC14->rCTL0.r = (ADC14->rCTL0.r
 309             & ~(ADC14SHT0_M | ADC14SHT1_M)) | secondPulseWidth
 310             | (firstPulseWidth >> 4);
 311
 312     return true;
 313 }
 314
 315 bool ADC14_configureMultiSequenceMode(uint32_t memoryStart, uint32_t memoryEnd,
 316 bool repeatMode)
 317 {
 318     uint32_t ii;
 319
 320     ASSERT(
 321             _getIndexForMemRegister(memoryStart) != ADC_INVALID_MEM
 322             && _getIndexForMemRegister(memoryEnd) != ADC_INVALID_MEM);
 323
 324     if (ADCIsConversionRunning())
 325         return false;
 326
 327     /* Clearing out any lingering EOS */
 328     for (ii = 0; ii < 32; ii++)
 329     {
 330         BITBAND_PERI(*(_ctlRegs[ii]), ADC14EOS_OFS) = 0;
 331     }
 332
 333     /* Setting Start/Stop locations */
 334     BITBAND_PERI(
 335             (*(_ctlRegs[_getIndexForMemRegister(memoryEnd)])),
 336             ADC14EOS_OFS) = 1;
 337
 338     ADC14->rCTL1.r = (ADC14->rCTL1.r & ~(ADC14CSTARTADD_M))
 339                     | (_getIndexForMemRegister(memoryStart) << 16);
 340
 341     /* Setting multiple sample mode */
 342     if (!repeatMode)
 343     {
 344         ADC14->rCTL0.r = (ADC14->rCTL0.r & ~(ADC14CONSEQ_M))
 345                 | (ADC14CONSEQ_1);
 346     } else
 347     {
 348         ADC14->rCTL0.r = (ADC14->rCTL0.r & ~(ADC14CONSEQ_M))
 349                 | (ADC14CONSEQ_3);
 350     }
 351
 352     return true;
 353 }
 354
 355 bool ADC14_configureSingleSampleMode(uint32_t memoryDestination,
 356 bool repeatMode)
 357 {
 358     ASSERT(_getIndexForMemRegister(memoryDestination) != 32);
 359
 360     if (ADCIsConversionRunning())
 361         return false;
 362
 363     /* Setting the destination register */
 364     ADC14->rCTL1.r = (ADC14->rCTL1.r & ~(ADC14CSTARTADD_M))
 365             | (_getIndexForMemRegister(memoryDestination) << 16);
 366
 367     /* Setting single sample mode */
 368     if (!repeatMode)
 369     {
 370         ADC14->rCTL0.r = (ADC14->rCTL0.r & ~(ADC14CONSEQ_M))
 371                 | (ADC14CONSEQ_0);
 372     } else
 373     {
 374         ADC14->rCTL0.r = (ADC14->rCTL0.r & ~(ADC14CONSEQ_M))
 375                 | (ADC14CONSEQ_2);
 376     }
 377
 378     return true;
 379 }
 380
 381 bool ADC14_enableConversion(void)
 382 {
 383     if (ADCIsConversionRunning() || !BITBAND_PERI(ADC14->rCTL0.r, ADC14ON_OFS))
 384         return false;
 385
 386     ADC14->rCTL0.r |= (ADC14ENC);
 387
 388     return true;
 389 }
 390
 391 bool ADC14_toggleConversionTrigger(void)
 392 {
 393     if (!BITBAND_PERI(ADC14->rCTL0.r, ADC14ON_OFS))
 394         return false;
 395
 396     if (BITBAND_PERI(ADC14->rCTL0.r, ADC14SC_OFS))
 397     {
 398         BITBAND_PERI(ADC14->rCTL0.r, ADC14SC_OFS) = 0;
 399     } else
 400     {
 401         BITBAND_PERI(ADC14->rCTL0.r, ADC14SC_OFS) = 1;
 402     }
 403
 404     return true;
 405 }
 406
 407 void ADC14_disableConversion(void)
 408 {
 409     ADC14->rCTL0.r &= ~(ADC14SC | ADC14ENC);
 410 }
 411
 412 bool ADC14_isBusy(void)
 413 {
 414     return BITBAND_PERI(ADC14->rCTL0.r, ADC14BUSY_OFS);
 415 }
 416
 417 bool ADC14_configureConversionMemory(uint32_t memorySelect, uint32_t refSelect,
 418         uint32_t channelSelect, bool differntialMode)
 419 {
 420     uint32_t currentReg, ii;
 421     uint32_t *curReg;
 422
 423     /* Initialization */
 424     ii = 1;
 425     currentReg = 0x01;
 426
 427     if (ADCIsConversionRunning())
 428         return false;
 429
 430     while (memorySelect != 0)
 431     {
 432         if (!(memorySelect & ii))
 433         {
 434             ii = ii << 1;
 435             continue;
 436         }
 437
 438         currentReg = memorySelect & ii;
 439         memorySelect &= ~ii;
 440         ii = ii << 1;
 441
 442         curReg = (uint32_t*) _ctlRegs[_getIndexForMemRegister(currentReg)];
 443
 444         if (differntialMode)
 445         {
 446             (*curReg) = ((*curReg)
 447                     & ~(ADC14VRSEL_M | ADC14INCH_M
 448                             | ADC14DIF))
 449                     | (channelSelect | refSelect | ADC14DIF);
 450         } else
 451         {
 452             (*curReg) = ((*curReg)
 453                     & ~(ADC14VRSEL_M | ADC14INCH_M
 454                             | ADC14DIF)) | (channelSelect | refSelect);
 455         }
 456
 457     }
 458
 459     return true;
 460 }
 461
 462 bool ADC14_enableComparatorWindow(uint32_t memorySelect, uint32_t windowSelect)
 463 {
 464     uint32_t currentReg, ii;
 465     uint32_t *curRegPoint;
 466
 467     /* Initialization */
 468     ii = 1;
 469     currentReg = 0x01;
 470
 471     if (ADCIsConversionRunning())
 472         return false;
 473
 474     while (memorySelect != 0)
 475     {
 476         if (!(memorySelect & ii))
 477         {
 478             ii = ii << 1;
 479             continue;
 480         }
 481
 482         currentReg = memorySelect & ii;
 483         memorySelect &= ~ii;
 484         ii = ii << 1;
 485
 486         curRegPoint =
 487                 (uint32_t*) _ctlRegs[_getIndexForMemRegister(currentReg)];
 488
 489         if (windowSelect == ADC_COMP_WINDOW0)
 490         {
 491             (*curRegPoint) = ((*curRegPoint)
 492                     & ~(ADC14WINC | ADC14WINCTH))
 493                     | (ADC14WINC);
 494         } else if (windowSelect == ADC_COMP_WINDOW1)
 495         {
 496             (*curRegPoint) |= ADC14WINC | ADC14WINCTH;
 497         }
 498
 499     }
 500
 501     return true;
 502 }
 503
 504 bool ADC14_disableComparatorWindow(uint32_t memorySelect)
 505 {
 506     uint32_t currentReg, ii;
 507
 508     /* Initialization */
 509     ii = 1;
 510     currentReg = 0x01;
 511
 512     if (ADCIsConversionRunning())
 513         return false;
 514
 515     while (memorySelect != 0)
 516     {
 517         if (!(memorySelect & ii))
 518         {
 519             ii = ii << 1;
 520             continue;
 521         }
 522
 523         currentReg = memorySelect & ii;
 524         memorySelect &= ~ii;
 525         ii = ii << 1;
 526
 527         (*(_ctlRegs[_getIndexForMemRegister(currentReg)])) &=
 528                 ~ADC14WINC;
 529
 530     }
 531
 532     return true;
 533 }
 534
 535 bool ADC14_setComparatorWindowValue(uint32_t window, int16_t low, int16_t high)
 536 {
 537     if (ADCIsConversionRunning())
 538         return false;
 539
 540     if (window == ADC_COMP_WINDOW0)
 541     {
 542         ADC14->rHI0.r = (high);
 543         ADC14->rLO0.r = (low);
 544
 545     } else if (window == ADC_COMP_WINDOW1)
 546     {
 547         ADC14->rHI1.r = (high);
 548         ADC14->rLO1.r = (low);
 549
 550     } else
 551     {
 552         ASSERT(false);
 553     }
 554
 555     return true;
 556 }
 557
 558 bool ADC14_setResultFormat(uint32_t resultFormat)
 559 {
 560     if (ADCIsConversionRunning())
 561         return false;
 562
 563     if (resultFormat == ADC_UNSIGNED_BINARY)
 564     {
 565         BITBAND_PERI(ADC14->rCTL1.r, ADC14DF_OFS) = 0;
 566     } else if (resultFormat == ADC_SIGNED_BINARY)
 567     {
 568         BITBAND_PERI(ADC14->rCTL1.r, ADC14DF_OFS) = 1;
 569     } else
 570     {
 571         ASSERT(false);
 572     }
 573
 574     return true;
 575 }
 576
 577 uint_fast16_t ADC14_getResult(uint32_t memorySelect)
 578 {
 579     return *((uint16_t*) (_ctlRegs[_getIndexForMemRegister(memorySelect)]
 580             + 0x80));
 581 }
 582
 583 void ADC14_getMultiSequenceResult(uint16_t* res)
 584 {
 585     uint32_t *startAddr, *curAddr;
 586     uint32_t ii;
 587
 588     startAddr = (uint32_t*) _ctlRegs[(ADC14->rCTL1.r & ADC14CSTARTADD_M)
 589             >> 16];
 590
 591     curAddr = startAddr;
 592
 593     for (ii = 0; ii < 32; ii++)
 594     {
 595         res[ii] = *(((uint16_t*) curAddr) + 0x80);
 596
 597         if (BITBAND_PERI((*curAddr), ADC14EOS_OFS))
 598             break;
 599
 600         if (curAddr == _ctlRegs[31])
 601             curAddr = (uint32_t*) _ctlRegs[0];
 602         else
 603             curAddr += 0x04;
 604     }
 605
 606 }
 607
 608 void ADC14_getResultArray(uint32_t memoryStart, uint32_t memoryEnd,
 609         uint16_t* res)
 610 {
 611     uint32_t ii = 0;
 612     uint32_t *firstPoint, *secondPoint;
 613
 614     bool foundEnd = false;
 615
 616     ASSERT(
 617             _getIndexForMemRegister(memoryStart) != ADC_INVALID_MEM
 618             && _getIndexForMemRegister(memoryEnd) != ADC_INVALID_MEM);
 619
 620     firstPoint = (uint32_t*) _ctlRegs[_getIndexForMemRegister(memoryStart)];
 621     secondPoint = (uint32_t*) _ctlRegs[_getIndexForMemRegister(memoryEnd)];
 622
 623     while (!foundEnd)
 624     {
 625         if (firstPoint == secondPoint)
 626         {
 627             foundEnd = true;
 628         }
 629
 630         res[ii] = *(((uint16_t*) firstPoint) + 0x80);
 631
 632         if (firstPoint == _ctlRegs[31])
 633             firstPoint = (uint32_t*) _ctlRegs[0];
 634         else
 635             firstPoint += 0x04;
 636     }
 637 }
 638
 639 bool ADC14_enableReferenceBurst(void)
 640 {
 641     if (ADCIsConversionRunning())
 642         return false;
 643
 644     BITBAND_PERI(ADC14->rCTL1.r, ADC14REFBURST_OFS) = 1;
 645
 646     return true;
 647 }
 648
 649 bool ADC14_disableReferenceBurst(void)
 650 {
 651     if (ADCIsConversionRunning())
 652         return false;
 653
 654     BITBAND_PERI(ADC14->rCTL1.r, ADC14REFBURST_OFS) = 0;
 655
 656     return true;
 657 }
 658
 659 bool ADC14_setPowerMode(uint32_t adcPowerMode)
 660 {
 661     if (ADCIsConversionRunning())
 662         return false;
 663
 664     switch (adcPowerMode)
 665     {
 666     case ADC_UNRESTRICTED_POWER_MODE:
 667         ADC14->rCTL1.r = (ADC14->rCTL1.r & ~(ADC14PWRMD_M))
 668                 | (ADC14PWRMD_0);
 669         break;
 670     case ADC_ULTRA_LOW_POWER_MODE:
 671         ADC14->rCTL1.r = (ADC14->rCTL1.r & ~(ADC14PWRMD_M))
 672                 | (ADC14PWRMD_2);
 673         break;
 674     default:
 675         ASSERT(false);
 676         return false;
 677     }
 678
 679     return true;
 680 }
 681
 682 void ADC14_enableInterrupt(uint_fast64_t mask)
 683 {
 684     uint32_t stat = mask & 0xFFFFFFFF;
 685
 686     ADC14->rIER0.r |= stat;
 687     stat = (mask >> 32);
 688     ADC14->rIER1.r |= (stat);
 689 }
 690
 691 void ADC14_disableInterrupt(uint_fast64_t mask)
 692 {
 693     uint32_t stat = mask & 0xFFFFFFFF;
 694
 695     ADC14->rIER0.r &= ~stat;
 696     stat = (mask >> 32);
 697     ADC14->rIER1.r &= ~(stat);
 698 }
 699
 700 uint_fast64_t ADC14_getInterruptStatus(void)
 701 {
 702     uint_fast64_t status = ADC14->rIFGR1.r;
 703     return ((status << 32) | ADC14->rIFGR0.r);
 704 }
 705
 706 uint_fast64_t ADC14_getEnabledInterruptStatus(void)
 707 {
 708     uint_fast64_t stat = ADC14->rIER1.r;
 709
 710     return ADC14_getInterruptStatus() & ((stat << 32) | ADC14->rIER0.r);
 711
 712 }
 713
 714 void ADC14_clearInterruptFlag(uint_fast64_t mask)
 715 {
 716     uint32_t stat = mask & 0xFFFFFFFF;
 717
 718     ADC14->rCLRIFGR0.r |= stat;
 719     stat = (mask >> 32);
 720     ADC14->rCLRIFGR1.r |= (stat);
 721 }
 722
 723 void ADC14_registerInterrupt(void (*intHandler)(void))
 724 {
 725     //
 726     // Register the interrupt handler, returning an error if an error occurs.
 727     //
 728     Interrupt_registerInterrupt(INT_ADC14, intHandler);
 729
 730     //
 731     // Enable the ADC interrupt.
 732     //
 733     Interrupt_enableInterrupt(INT_ADC14);
 734 }
 735
 736 void ADC14_unregisterInterrupt(void)
 737 {
 738     //
 739     // Disable the interrupt.
 740     //
 741     Interrupt_disableInterrupt(INT_ADC14);
 742
 743     //
 744     // Unregister the interrupt handler.
 745     //
 746     Interrupt_unregisterInterrupt(INT_ADC14);
 747 }
 748