1 /* --COPYRIGHT--,BSD 2 * Copyright (c) 2017, Texas Instruments Incorporated 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * * Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * * Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * * Neither the name of Texas Instruments Incorporated nor the names of 17 * its contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 * --/COPYRIGHT--*/ 32 /* Standard Includes */ 33 #include <stdint.h> 34 #include <stdbool.h> 35 36 /* DriverLib Includes */ 37 #include <ti/devices/msp432p4xx/driverlib/adc14.h> 38 #include <ti/devices/msp432p4xx/driverlib/debug.h> 39 #include <ti/devices/msp432p4xx/driverlib/interrupt.h> 40 41 /* Statics */ 42 static volatile uint32_t* const _ctlRegs[32] = 43 { &ADC14->MCTL[0], &ADC14->MCTL[1], &ADC14->MCTL[2], &ADC14->MCTL[3], 44 &ADC14->MCTL[4], &ADC14->MCTL[5], &ADC14->MCTL[6], &ADC14->MCTL[7], 45 &ADC14->MCTL[8], &ADC14->MCTL[9], &ADC14->MCTL[10], 46 &ADC14->MCTL[11], &ADC14->MCTL[12], &ADC14->MCTL[13], 47 &ADC14->MCTL[14], &ADC14->MCTL[15], &ADC14->MCTL[16], 48 &ADC14->MCTL[17], &ADC14->MCTL[18], &ADC14->MCTL[19], 49 &ADC14->MCTL[20], &ADC14->MCTL[21], &ADC14->MCTL[22], 50 &ADC14->MCTL[23], &ADC14->MCTL[24], &ADC14->MCTL[25], 51 &ADC14->MCTL[26], &ADC14->MCTL[27], &ADC14->MCTL[28], 52 &ADC14->MCTL[29], &ADC14->MCTL[30], &ADC14->MCTL[31] }; 53 54 static uint_fast8_t _getIndexForMemRegister(uint32_t reg) 55 { 56 switch (reg) 57 { 58 case ADC_MEM0: 59 return 0; 60 case ADC_MEM1: 61 return 1; 62 case ADC_MEM2: 63 return 2; 64 case ADC_MEM3: 65 return 3; 66 case ADC_MEM4: 67 return 4; 68 case ADC_MEM5: 69 return 5; 70 case ADC_MEM6: 71 return 6; 72 case ADC_MEM7: 73 return 7; 74 case ADC_MEM8: 75 return 8; 76 case ADC_MEM9: 77 return 9; 78 case ADC_MEM10: 79 return 10; 80 case ADC_MEM11: 81 return 11; 82 case ADC_MEM12: 83 return 12; 84 case ADC_MEM13: 85 return 13; 86 case ADC_MEM14: 87 return 14; 88 case ADC_MEM15: 89 return 15; 90 case ADC_MEM16: 91 return 16; 92 case ADC_MEM17: 93 return 17; 94 case ADC_MEM18: 95 return 18; 96 case ADC_MEM19: 97 return 19; 98 case ADC_MEM20: 99 return 20; 100 case ADC_MEM21: 101 return 21; 102 case ADC_MEM22: 103 return 22; 104 case ADC_MEM23: 105 return 23; 106 case ADC_MEM24: 107 return 24; 108 case ADC_MEM25: 109 return 25; 110 case ADC_MEM26: 111 return 26; 112 case ADC_MEM27: 113 return 27; 114 case ADC_MEM28: 115 return 28; 116 case ADC_MEM29: 117 return 29; 118 case ADC_MEM30: 119 return 30; 120 case ADC_MEM31: 121 return 31; 122 default: 123 ASSERT(false); 124 return ADC_INVALID_MEM; 125 126 } 127 } 128 129 //***************************************************************************** 130 // 131 //! 132 //! Returns a boolean value that tells if conversion is active/running or is 133 //! not acMSP432 ted. 134 //! 135 //! Originally a public function, but moved to static. External customers should 136 //! use the ADC14_isBusy function. 137 //! 138 //! \return true if conversion is active, false otherwise 139 // 140 //***************************************************************************** 141 static bool ADCIsConversionRunning(void) 142 { 143 return BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_BUSY_OFS); 144 } 145 146 void ADC14_enableModule(void) 147 { 148 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_ON_OFS) = 1; 149 } 150 151 bool ADC14_disableModule(void) 152 { 153 if (ADCIsConversionRunning()) 154 return false; 155 156 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_ON_OFS) = 0; 157 158 return true; 159 } 160 161 bool ADC14_enableSampleTimer(uint32_t multiSampleConvert) 162 { 163 if (ADCIsConversionRunning()) 164 return false; 165 166 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_SHP_OFS) = 1; 167 168 if (multiSampleConvert == ADC_MANUAL_ITERATION) 169 { 170 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_MSC_OFS) = 0; 171 } else 172 { 173 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_MSC_OFS) = 1; 174 } 175 176 return true; 177 } 178 179 bool ADC14_disableSampleTimer(void) 180 { 181 if (ADCIsConversionRunning()) 182 return false; 183 184 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_SHP_OFS) = 0; 185 186 return true; 187 } 188 189 bool ADC14_initModule(uint32_t clockSource, uint32_t clockPredivider, 190 uint32_t clockDivider, uint32_t internalChannelMask) 191 { 192 ASSERT( 193 clockSource == ADC_CLOCKSOURCE_ADCOSC 194 || clockSource == ADC_CLOCKSOURCE_SYSOSC 195 || clockSource == ADC_CLOCKSOURCE_ACLK 196 || clockSource == ADC_CLOCKSOURCE_MCLK 197 || clockSource == ADC_CLOCKSOURCE_SMCLK 198 || clockSource == ADC_CLOCKSOURCE_HSMCLK); 199 200 ASSERT( 201 clockPredivider == ADC_PREDIVIDER_1 202 || clockPredivider == ADC_PREDIVIDER_4 203 || clockPredivider == ADC_PREDIVIDER_32 204 || clockPredivider == ADC_PREDIVIDER_64); 205 206 ASSERT( 207 clockDivider == ADC_DIVIDER_1 || clockDivider == ADC_DIVIDER_2 208 || clockDivider == ADC_DIVIDER_3 209 || clockDivider == ADC_DIVIDER_4 210 || clockDivider == ADC_DIVIDER_5 211 || clockDivider == ADC_DIVIDER_6 212 || clockDivider == ADC_DIVIDER_7 213 || clockDivider == ADC_DIVIDER_8); 214 215 ASSERT( 216 !(internalChannelMask 217 & ~(ADC_MAPINTCH3 | ADC_MAPINTCH2 | ADC_MAPINTCH1 218 | ADC_MAPINTCH0 | ADC_TEMPSENSEMAP | ADC_BATTMAP))); 219 220 if (ADCIsConversionRunning()) 221 return false; 222 223 ADC14->CTL0 = (ADC14->CTL0 224 & ~(ADC14_CTL0_PDIV_MASK | ADC14_CTL0_DIV_MASK | ADC14_CTL0_SSEL_MASK)) 225 | clockDivider | clockPredivider | clockSource; 226 227 ADC14->CTL1 = (ADC14->CTL1 228 & ~(ADC_MAPINTCH3 | ADC_MAPINTCH2 | ADC_MAPINTCH1 | ADC_MAPINTCH0 229 | ADC_TEMPSENSEMAP | ADC_BATTMAP)) | internalChannelMask; 230 231 return true; 232 } 233 234 void ADC14_setResolution(uint32_t resolution) 235 { 236 ASSERT( 237 resolution == ADC_8BIT || resolution == ADC_10BIT 238 || resolution == ADC_12BIT || resolution == ADC_14BIT); 239 240 ADC14->CTL1 = (ADC14->CTL1 & ~ADC14_CTL1_RES_MASK) | resolution; 241 } 242 243 uint_fast32_t ADC14_getResolution(void) 244 { 245 return ADC14->CTL1 & ADC14_CTL1_RES_MASK; 246 } 247 248 bool ADC14_setSampleHoldTrigger(uint32_t source, bool invertSignal) 249 { 250 251 ASSERT( 252 source == ADC_TRIGGER_ADCSC || source == ADC_TRIGGER_SOURCE1 253 || source == ADC_TRIGGER_SOURCE2 254 || source == ADC_TRIGGER_SOURCE3 255 || source == ADC_TRIGGER_SOURCE4 256 || source == ADC_TRIGGER_SOURCE5 257 || source == ADC_TRIGGER_SOURCE6 258 || source == ADC_TRIGGER_SOURCE7); 259 260 if (ADCIsConversionRunning()) 261 return false; 262 263 if (invertSignal) 264 { 265 ADC14->CTL0 = (ADC14->CTL0 266 & ~(ADC14_CTL0_ISSH | ADC14_CTL0_SHS_MASK)) | source 267 | ADC14_CTL0_ISSH; 268 } else 269 { 270 ADC14->CTL0 = (ADC14->CTL0 271 & ~(ADC14_CTL0_ISSH | ADC14_CTL0_SHS_MASK)) | source; 272 } 273 274 return true; 275 } 276 277 bool ADC14_setSampleHoldTime(uint32_t firstPulseWidth, 278 uint32_t secondPulseWidth) 279 { 280 ASSERT( 281 firstPulseWidth == ADC_PULSE_WIDTH_4 282 || firstPulseWidth == ADC_PULSE_WIDTH_8 283 || firstPulseWidth == ADC_PULSE_WIDTH_16 284 || firstPulseWidth == ADC_PULSE_WIDTH_32 285 || firstPulseWidth == ADC_PULSE_WIDTH_64 286 || firstPulseWidth == ADC_PULSE_WIDTH_96 287 || firstPulseWidth == ADC_PULSE_WIDTH_128 288 || firstPulseWidth == ADC_PULSE_WIDTH_192); 289 290 ASSERT( 291 secondPulseWidth == ADC_PULSE_WIDTH_4 292 || secondPulseWidth == ADC_PULSE_WIDTH_8 293 || secondPulseWidth == ADC_PULSE_WIDTH_16 294 || secondPulseWidth == ADC_PULSE_WIDTH_32 295 || secondPulseWidth == ADC_PULSE_WIDTH_64 296 || secondPulseWidth == ADC_PULSE_WIDTH_96 297 || secondPulseWidth == ADC_PULSE_WIDTH_128 298 || secondPulseWidth == ADC_PULSE_WIDTH_192); 299 300 if (ADCIsConversionRunning()) 301 return false; 302 303 ADC14->CTL0 = (ADC14->CTL0 304 & ~(ADC14_CTL0_SHT0_MASK | ADC14_CTL0_SHT1_MASK)) | secondPulseWidth 305 | (firstPulseWidth >> 4); 306 307 return true; 308 } 309 310 bool ADC14_configureMultiSequenceMode(uint32_t memoryStart, uint32_t memoryEnd, 311 bool repeatMode) 312 { 313 uint32_t ii; 314 315 ASSERT( 316 _getIndexForMemRegister(memoryStart) != ADC_INVALID_MEM 317 && _getIndexForMemRegister(memoryEnd) != ADC_INVALID_MEM); 318 319 if (ADCIsConversionRunning()) 320 return false; 321 322 /* Clearing out any lingering EOS */ 323 for (ii = 0; ii < 32; ii++) 324 { 325 BITBAND_PERI(*(_ctlRegs[ii]), ADC14_MCTLN_EOS_OFS) = 0; 326 } 327 328 uint_fast8_t memEndIndex = _getIndexForMemRegister(memoryEnd); 329 if (memEndIndex != ADC_INVALID_MEM) 330 { 331 /* Setting Start/Stop locations */ 332 BITBAND_PERI( 333 (*(_ctlRegs[memEndIndex])), 334 ADC14_MCTLN_EOS_OFS) = 1; 335 336 ADC14->CTL1 = (ADC14->CTL1 & ~(ADC14_CTL1_CSTARTADD_MASK)) 337 | (_getIndexForMemRegister(memoryStart) << 16); 338 339 /* Setting multiple sample mode */ 340 if (!repeatMode) 341 { 342 ADC14->CTL0 = (ADC14->CTL0 & ~(ADC14_CTL0_CONSEQ_MASK)) 343 | (ADC14_CTL0_CONSEQ_1); 344 } else 345 { 346 ADC14->CTL0 = (ADC14->CTL0 & ~(ADC14_CTL0_CONSEQ_MASK)) 347 | (ADC14_CTL0_CONSEQ_3); 348 } 349 350 return true; 351 } 352 else 353 { 354 return false; 355 } 356 } 357 358 bool ADC14_configureSingleSampleMode(uint32_t memoryDestination, 359 bool repeatMode) 360 { 361 ASSERT(_getIndexForMemRegister(memoryDestination) != 32); 362 363 if (ADCIsConversionRunning()) 364 return false; 365 366 /* Setting the destination register */ 367 ADC14->CTL1 = (ADC14->CTL1 & ~(ADC14_CTL1_CSTARTADD_MASK)) 368 | (_getIndexForMemRegister(memoryDestination) << 16); 369 370 /* Setting single sample mode */ 371 if (!repeatMode) 372 { 373 ADC14->CTL0 = (ADC14->CTL0 & ~(ADC14_CTL0_CONSEQ_MASK)) 374 | (ADC14_CTL0_CONSEQ_0); 375 } else 376 { 377 ADC14->CTL0 = (ADC14->CTL0 & ~(ADC14_CTL0_CONSEQ_MASK)) 378 | (ADC14_CTL0_CONSEQ_2); 379 } 380 381 return true; 382 } 383 384 bool ADC14_enableConversion(void) 385 { 386 if (ADCIsConversionRunning() || !BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_ON_OFS)) 387 return false; 388 389 ADC14->CTL0 |= (ADC14_CTL0_ENC); 390 391 return true; 392 } 393 394 bool ADC14_toggleConversionTrigger(void) 395 { 396 if (!BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_ON_OFS)) 397 return false; 398 399 if (BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_SC_OFS)) 400 { 401 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_SC_OFS) = 0; 402 } else 403 { 404 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_SC_OFS) = 1; 405 } 406 407 return true; 408 } 409 410 void ADC14_disableConversion(void) 411 { 412 ADC14->CTL0 &= ~(ADC14_CTL0_SC | ADC14_CTL0_ENC); 413 } 414 415 bool ADC14_isBusy(void) 416 { 417 return BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_BUSY_OFS); 418 } 419 420 bool ADC14_configureConversionMemory(uint32_t memorySelect, uint32_t refSelect, 421 uint32_t channelSelect, bool differntialMode) 422 { 423 uint32_t currentReg, ii; 424 uint32_t *curReg; 425 426 /* Initialization */ 427 ii = 1; 428 currentReg = 0x01; 429 430 if (ADCIsConversionRunning()) 431 return false; 432 433 while (memorySelect != 0) 434 { 435 if (!(memorySelect & ii)) 436 { 437 ii = ii << 1; 438 continue; 439 } 440 441 currentReg = memorySelect & ii; 442 memorySelect &= ~ii; 443 ii = ii << 1; 444 445 uint_fast8_t currRegIndex = _getIndexForMemRegister(currentReg); 446 if (currRegIndex != ADC_INVALID_MEM) 447 { 448 curReg = (uint32_t*) _ctlRegs[currRegIndex]; 449 450 if (differntialMode) 451 { 452 (*curReg) = ((*curReg) 453 & ~(ADC14_MCTLN_VRSEL_MASK | ADC14_MCTLN_INCH_MASK 454 | ADC14_MCTLN_DIF)) 455 | (channelSelect | refSelect | ADC14_MCTLN_DIF); 456 } else 457 { 458 (*curReg) = ((*curReg) 459 & ~(ADC14_MCTLN_VRSEL_MASK | ADC14_MCTLN_INCH_MASK 460 | ADC14_MCTLN_DIF)) | (channelSelect | refSelect); 461 } 462 } 463 else 464 { 465 return false; 466 } 467 } 468 469 return true; 470 } 471 472 bool ADC14_enableComparatorWindow(uint32_t memorySelect, uint32_t windowSelect) 473 { 474 uint32_t currentReg, ii; 475 uint32_t *curRegPoint; 476 477 /* Initialization */ 478 ii = 1; 479 currentReg = 0x01; 480 481 if (ADCIsConversionRunning()) 482 return false; 483 484 while (memorySelect != 0) 485 { 486 if (!(memorySelect & ii)) 487 { 488 ii = ii << 1; 489 continue; 490 } 491 492 currentReg = memorySelect & ii; 493 memorySelect &= ~ii; 494 ii = ii << 1; 495 496 uint_fast8_t currRegIndex = _getIndexForMemRegister(currentReg); 497 if (currRegIndex != ADC_INVALID_MEM) 498 { 499 curRegPoint = 500 (uint32_t*) _ctlRegs[currRegIndex]; 501 502 if (windowSelect == ADC_COMP_WINDOW0) 503 { 504 (*curRegPoint) = ((*curRegPoint) 505 & ~(ADC14_MCTLN_WINC | ADC14_MCTLN_WINCTH)) 506 | (ADC14_MCTLN_WINC); 507 } else if (windowSelect == ADC_COMP_WINDOW1) 508 { 509 (*curRegPoint) |= ADC14_MCTLN_WINC | ADC14_MCTLN_WINCTH; 510 } 511 } 512 else 513 { 514 return false; 515 } 516 517 } 518 519 return true; 520 } 521 522 bool ADC14_disableComparatorWindow(uint32_t memorySelect) 523 { 524 uint32_t currentReg, ii; 525 526 /* Initialization */ 527 ii = 1; 528 currentReg = 0x01; 529 530 if (ADCIsConversionRunning()) 531 return false; 532 533 while (memorySelect != 0) 534 { 535 if (!(memorySelect & ii)) 536 { 537 ii = ii << 1; 538 continue; 539 } 540 541 currentReg = memorySelect & ii; 542 memorySelect &= ~ii; 543 ii = ii << 1; 544 545 (*(_ctlRegs[_getIndexForMemRegister(currentReg)])) &= 546 ~ADC14_MCTLN_WINC; 547 548 } 549 550 return true; 551 } 552 553 bool ADC14_setComparatorWindowValue(uint32_t window, int16_t low, int16_t high) 554 { 555 if (ADCIsConversionRunning()) 556 return false; 557 558 if(BITBAND_PERI(ADC14->CTL1, ADC14_CTL1_DF_OFS)) 559 { 560 low = ((low << 2) | (0x8000 & low)) & 0xFFFC; 561 high = ((high << 2) | (0x8000 & high)) & 0xFFFC; 562 } 563 564 if (window == ADC_COMP_WINDOW0) 565 { 566 ADC14->HI0 = (high); 567 ADC14->LO0 = (low); 568 569 } else if (window == ADC_COMP_WINDOW1) 570 { 571 ADC14->HI1 = (high); 572 ADC14->LO1 = (low); 573 574 } else 575 { 576 ASSERT(false); 577 return false; 578 } 579 580 return true; 581 } 582 583 bool ADC14_setResultFormat(uint32_t resultFormat) 584 { 585 if (ADCIsConversionRunning()) 586 return false; 587 588 if (resultFormat == ADC_UNSIGNED_BINARY) 589 { 590 BITBAND_PERI(ADC14->CTL1, ADC14_CTL1_DF_OFS) = 0; 591 } else if (resultFormat == ADC_SIGNED_BINARY) 592 { 593 BITBAND_PERI(ADC14->CTL1, ADC14_CTL1_DF_OFS) = 1; 594 } else 595 { 596 ASSERT(false); 597 } 598 599 return true; 600 } 601 602 uint_fast16_t ADC14_getResult(uint32_t memorySelect) 603 { 604 uint_fast8_t memSelIndex = _getIndexForMemRegister(memorySelect); 605 if (memSelIndex != ADC_INVALID_MEM) 606 { 607 return *((uint16_t*) (_ctlRegs[memSelIndex] 608 + 0x20)); 609 } 610 else 611 { 612 return 0; 613 } 614 } 615 616 void ADC14_getMultiSequenceResult(uint16_t* res) 617 { 618 619 uint32_t startIndex, ii; 620 621 startIndex = (ADC14->CTL1 & ADC14_CTL1_CSTARTADD_MASK)>>16; 622 623 for (ii = startIndex; ii < 32; ii++) 624 { 625 res[ii] = ADC14->MEM[ii]; 626 627 if(ADC14->MCTL[ii] & ADC14_MCTLN_EOS) 628 break; 629 630 } 631 632 } 633 634 void ADC14_getResultArray(uint32_t memoryStart, uint32_t memoryEnd, 635 uint16_t* res) 636 { 637 uint32_t ii = 0; 638 uint32_t *firstPoint, *secondPoint; 639 640 bool foundEnd = false; 641 642 uint_fast8_t memStartIndex, memEndIndex; 643 644 memStartIndex = _getIndexForMemRegister(memoryStart); 645 memEndIndex = _getIndexForMemRegister(memoryEnd); 646 647 ASSERT( 648 _getIndexForMemRegister(memoryStart) != ADC_INVALID_MEM 649 && _getIndexForMemRegister(memoryEnd) != ADC_INVALID_MEM); 650 651 if (memStartIndex != ADC_INVALID_MEM && memEndIndex!= ADC_INVALID_MEM) { 652 firstPoint = (uint32_t*) _ctlRegs[memStartIndex]; 653 secondPoint = (uint32_t*) _ctlRegs[memEndIndex]; 654 655 while (!foundEnd) 656 { 657 if (firstPoint == secondPoint) 658 { 659 foundEnd = true; 660 } 661 662 res[ii] = *(((uint16_t*) firstPoint) + 0x40); 663 664 if (firstPoint == _ctlRegs[31]) 665 firstPoint = (uint32_t*) _ctlRegs[0]; 666 else 667 firstPoint += 0x04; 668 } 669 } 670 } 671 672 bool ADC14_enableReferenceBurst(void) 673 { 674 if (ADCIsConversionRunning()) 675 return false; 676 677 BITBAND_PERI(ADC14->CTL1, ADC14_CTL1_REFBURST_OFS) = 1; 678 679 return true; 680 } 681 682 bool ADC14_disableReferenceBurst(void) 683 { 684 if (ADCIsConversionRunning()) 685 return false; 686 687 BITBAND_PERI(ADC14->CTL1, ADC14_CTL1_REFBURST_OFS) = 0; 688 689 return true; 690 } 691 692 bool ADC14_setPowerMode(uint32_t adcPowerMode) 693 { 694 if (ADCIsConversionRunning()) 695 return false; 696 697 switch (adcPowerMode) 698 { 699 case ADC_UNRESTRICTED_POWER_MODE: 700 ADC14->CTL1 = (ADC14->CTL1 & ~(ADC14_CTL1_PWRMD_MASK)) 701 | (ADC14_CTL1_PWRMD_0); 702 break; 703 case ADC_ULTRA_LOW_POWER_MODE: 704 ADC14->CTL1 = (ADC14->CTL1 & ~(ADC14_CTL1_PWRMD_MASK)) 705 | (ADC14_CTL1_PWRMD_2); 706 break; 707 default: 708 ASSERT(false); 709 return false; 710 } 711 712 return true; 713 } 714 715 void ADC14_enableInterrupt(uint_fast64_t mask) 716 { 717 uint32_t stat = mask & 0xFFFFFFFF; 718 719 ADC14->IER0 |= stat; 720 stat = (mask >> 32); 721 ADC14->IER1 |= (stat); 722 } 723 724 void ADC14_disableInterrupt(uint_fast64_t mask) 725 { 726 uint32_t stat = mask & 0xFFFFFFFF; 727 728 ADC14->IER0 &= ~stat; 729 stat = (mask >> 32); 730 ADC14->IER1 &= ~(stat); 731 } 732 733 uint_fast64_t ADC14_getInterruptStatus(void) 734 { 735 uint_fast64_t status = ADC14->IFGR1; 736 return ((status << 32) | ADC14->IFGR0); 737 } 738 739 uint_fast64_t ADC14_getEnabledInterruptStatus(void) 740 { 741 uint_fast64_t stat = ADC14->IER1; 742 743 return ADC14_getInterruptStatus() & ((stat << 32) | ADC14->IER0); 744 745 } 746 747 void ADC14_clearInterruptFlag(uint_fast64_t mask) 748 { 749 uint32_t stat = mask & 0xFFFFFFFF; 750 751 ADC14->CLRIFGR0 |= stat; 752 stat = (mask >> 32); 753 ADC14->CLRIFGR1 |= (stat); 754 } 755 756 void ADC14_registerInterrupt(void (*intHandler)(void)) 757 { 758 // 759 // Register the interrupt handler, returning an error if an error occurs. 760 // 761 Interrupt_registerInterrupt(INT_ADC14, intHandler); 762 763 // 764 // Enable the ADC interrupt. 765 // 766 Interrupt_enableInterrupt(INT_ADC14); 767 } 768 769 void ADC14_unregisterInterrupt(void) 770 { 771 // 772 // Disable the interrupt. 773 // 774 Interrupt_disableInterrupt(INT_ADC14); 775 776 // 777 // Unregister the interrupt handler. 778 // 779 Interrupt_unregisterInterrupt(INT_ADC14); 780 } 781 782