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
_getIndexForMemRegister(uint32_t reg)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 //*****************************************************************************
ADCIsConversionRunning(void)141 static bool ADCIsConversionRunning(void)
142 {
143 return BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_BUSY_OFS);
144 }
145
ADC14_enableModule(void)146 void ADC14_enableModule(void)
147 {
148 BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_ON_OFS) = 1;
149 }
150
ADC14_disableModule(void)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
ADC14_enableSampleTimer(uint32_t multiSampleConvert)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
ADC14_disableSampleTimer(void)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
ADC14_initModule(uint32_t clockSource,uint32_t clockPredivider,uint32_t clockDivider,uint32_t internalChannelMask)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
ADC14_setResolution(uint32_t resolution)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
ADC14_getResolution(void)243 uint_fast32_t ADC14_getResolution(void)
244 {
245 return ADC14->CTL1 & ADC14_CTL1_RES_MASK;
246 }
247
ADC14_setSampleHoldTrigger(uint32_t source,bool invertSignal)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
ADC14_setSampleHoldTime(uint32_t firstPulseWidth,uint32_t secondPulseWidth)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
ADC14_configureMultiSequenceMode(uint32_t memoryStart,uint32_t memoryEnd,bool repeatMode)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
ADC14_configureSingleSampleMode(uint32_t memoryDestination,bool repeatMode)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
ADC14_enableConversion(void)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
ADC14_toggleConversionTrigger(void)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
ADC14_disableConversion(void)410 void ADC14_disableConversion(void)
411 {
412 ADC14->CTL0 &= ~(ADC14_CTL0_SC | ADC14_CTL0_ENC);
413 }
414
ADC14_isBusy(void)415 bool ADC14_isBusy(void)
416 {
417 return BITBAND_PERI(ADC14->CTL0, ADC14_CTL0_BUSY_OFS);
418 }
419
ADC14_configureConversionMemory(uint32_t memorySelect,uint32_t refSelect,uint32_t channelSelect,bool differntialMode)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
ADC14_enableComparatorWindow(uint32_t memorySelect,uint32_t windowSelect)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
ADC14_disableComparatorWindow(uint32_t memorySelect)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
ADC14_setComparatorWindowValue(uint32_t window,int16_t low,int16_t high)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
ADC14_setResultFormat(uint32_t resultFormat)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
ADC14_getResult(uint32_t memorySelect)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
ADC14_getMultiSequenceResult(uint16_t * res)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
ADC14_getResultArray(uint32_t memoryStart,uint32_t memoryEnd,uint16_t * res)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
ADC14_enableReferenceBurst(void)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
ADC14_disableReferenceBurst(void)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
ADC14_setPowerMode(uint32_t adcPowerMode)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
ADC14_enableInterrupt(uint_fast64_t mask)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
ADC14_disableInterrupt(uint_fast64_t mask)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
ADC14_getInterruptStatus(void)733 uint_fast64_t ADC14_getInterruptStatus(void)
734 {
735 uint_fast64_t status = ADC14->IFGR1;
736 return ((status << 32) | ADC14->IFGR0);
737 }
738
ADC14_getEnabledInterruptStatus(void)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
ADC14_clearInterruptFlag(uint_fast64_t mask)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
ADC14_registerInterrupt(void (* intHandler)(void))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
ADC14_unregisterInterrupt(void)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