MSP430™CapTIvateSoftwareLibraryAPIGuide 1_70_00_03

rom_map_captivate.h
Go to the documentation of this file.
1 //*****************************************************************************
2 //
3 // rom_map_captivate.h
4 // Macros to facilitate calling functions in the ROM
5 // API table when they are available in a device.
6 //
9 //
10 //*****************************************************************************
11
12 #ifndef __ROM_MAP_CAPTIVATE_H__
13 #define __ROM_MAP_CAPTIVATE_H__
14
15 //*****************************************************************************
16 //
17 // Calling Macros for the CapTIvate Software Library
18 // There are 171 APIs in the CapTIvate library.
19 //
20 //*****************************************************************************
21
22 // ROM vs. FRAM Calling Macro for CAPT_processButtons()
23 #ifdef ROM_CAPT_processButtons
24 #define MAP_CAPT_processButtons \
25 ROM_CAPT_processButtons
26 #else
27 #define MAP_CAPT_processButtons \
28 CAPT_processButtons
29 #endif
30
31 // ROM vs. FRAM Calling Macro for CAPT_getDominantButton()
32 #ifdef ROM_CAPT_getDominantButton
33 #define MAP_CAPT_getDominantButton \
34 ROM_CAPT_getDominantButton
35 #else
36 #define MAP_CAPT_getDominantButton \
37 CAPT_getDominantButton
38 #endif
39
40 // ROM vs. FRAM Calling Macro for CAPT_getDominantButtonAddr()
41 #ifdef ROM_CAPT_getDominantButtonAddr
42 #define MAP_CAPT_getDominantButtonAddr \
43 ROM_CAPT_getDominantButtonAddr
44 #else
45 #define MAP_CAPT_getDominantButtonAddr \
46 CAPT_getDominantButtonAddr
47 #endif
48
49 // ROM vs. FRAM Calling Macro for CAPT_calibrateSensor()
50 #ifdef ROM_CAPT_calibrateSensor
51 #define MAP_CAPT_calibrateSensor \
52 ROM_CAPT_calibrateSensor
53 #else
54 #define MAP_CAPT_calibrateSensor \
55 CAPT_calibrateSensor
56 #endif
57
58 // ROM vs. FRAM Calling Macro for CAPT_calibrateSensorWithMaxOffset()
59 #ifdef ROM_CAPT_calibrateSensorWithMaxOffset
60 #define MAP_CAPT_calibrateSensorWithMaxOffset \
61 ROM_CAPT_calibrateSensorWithMaxOffset
62 #else
63 #define MAP_CAPT_calibrateSensorWithMaxOffset \
64 CAPT_calibrateSensorWithMaxOffset
65 #endif
66
67 // ROM vs. FRAM Calling Macro for CAPT_calibrateSensorWithEMC()
68 #ifdef ROM_CAPT_calibrateSensorWithEMC
69 #define MAP_CAPT_calibrateSensorWithEMC \
70 ROM_CAPT_calibrateSensorWithEMC
71 #else
72 #define MAP_CAPT_calibrateSensorWithEMC \
73 CAPT_calibrateSensorWithEMC
74 #endif
75
76 // ROM vs. FRAM Calling Macro for CAPT_calibrateSensorWithMaxOffsetWithEMC()
77 #ifdef ROM_CAPT_calibrateSensorWithMaxOffsetWithEMC
78 #define MAP_CAPT_calibrateSensorWithMaxOffsetWithEMC \
79 ROM_CAPT_calibrateSensorWithMaxOffsetWithEMC
80 #else
81 #define MAP_CAPT_calibrateSensorWithMaxOffsetWithEMC \
82 CAPT_calibrateSensorWithMaxOffsetWithEMC
83 #endif
84
85 // ROM vs. FRAM Calling Macro for CAPT_calibrateGain()
86 #ifdef ROM_CAPT_calibrateGain
87 #define MAP_CAPT_calibrateGain \
88 ROM_CAPT_calibrateGain
89 #else
90 #define MAP_CAPT_calibrateGain \
91 CAPT_calibrateGain
92 #endif
93
94 // ROM vs. FRAM Calling Macro for CAPT_calibrateOffset()
95 #ifdef ROM_CAPT_calibrateOffset
96 #define MAP_CAPT_calibrateOffset \
97 ROM_CAPT_calibrateOffset
98 #else
99 #define MAP_CAPT_calibrateOffset \
100 CAPT_calibrateOffset
101 #endif
102
103 // ROM vs. FRAM Calling Macro for CAPT_getElementMaxCountStatus()
104 #ifdef ROM_CAPT_getElementMaxCountStatus
105 #define MAP_CAPT_getElementMaxCountStatus \
106 ROM_CAPT_getElementMaxCountStatus
107 #else
108 #define MAP_CAPT_getElementMaxCountStatus \
109 CAPT_getElementMaxCountStatus
110 #endif
111
112 // ROM vs. FRAM Calling Macro for CAPT_calibrateForMaxOffset()
113 #ifdef ROM_CAPT_calibrateForMaxOffset
114 #define MAP_CAPT_calibrateForMaxOffset \
115 ROM_CAPT_calibrateForMaxOffset
116 #else
117 #define MAP_CAPT_calibrateForMaxOffset \
118 CAPT_calibrateForMaxOffset
119 #endif
120
121 // ROM vs. FRAM Calling Macro for CAPT_loadEMCConfig()
122 #ifdef ROM_CAPT_loadEMCConfig
123 #define MAP_CAPT_loadEMCConfig \
124 ROM_CAPT_loadEMCConfig
125 #else
126 #define MAP_CAPT_loadEMCConfig \
127 CAPT_loadEMCConfig
128 #endif
129
130 // ROM vs. FRAM Calling Macro for CAPT_getGlobalFilteredNoiseLevel()
131 #ifdef ROM_CAPT_getGlobalFilteredNoiseLevel
132 #define MAP_CAPT_getGlobalFilteredNoiseLevel \
133 ROM_CAPT_getGlobalFilteredNoiseLevel
134 #else
135 #define MAP_CAPT_getGlobalFilteredNoiseLevel \
136 CAPT_getGlobalFilteredNoiseLevel
137 #endif
138
139 // ROM vs. FRAM Calling Macro for CAPT_resetGlobalFilteredNoiseLevel()
140 #ifdef ROM_CAPT_resetGlobalFilteredNoiseLevel
141 #define MAP_CAPT_resetGlobalFilteredNoiseLevel \
142 ROM_CAPT_resetGlobalFilteredNoiseLevel
143 #else
144 #define MAP_CAPT_resetGlobalFilteredNoiseLevel \
145 CAPT_resetGlobalFilteredNoiseLevel
146 #endif
147
148 // ROM vs. FRAM Calling Macro for CAPT_updateGlobalFilteredNoiseLevel()
149 #ifdef ROM_CAPT_updateGlobalFilteredNoiseLevel
150 #define MAP_CAPT_updateGlobalFilteredNoiseLevel \
151 ROM_CAPT_updateGlobalFilteredNoiseLevel
152 #else
153 #define MAP_CAPT_updateGlobalFilteredNoiseLevel \
154 CAPT_updateGlobalFilteredNoiseLevel
155 #endif
156
157 // ROM vs. FRAM Calling Macro for CAPT_getEMCConversionSettings()
158 #ifdef ROM_CAPT_getEMCConversionSettings
159 #define MAP_CAPT_getEMCConversionSettings \
160 ROM_CAPT_getEMCConversionSettings
161 #else
162 #define MAP_CAPT_getEMCConversionSettings \
163 CAPT_getEMCConversionSettings
164 #endif
165
166 // ROM vs. FRAM Calling Macro for CAPT_getRelNoiseStatusThreshold()
167 #ifdef ROM_CAPT_getRelNoiseStatusThreshold
168 #define MAP_CAPT_getRelNoiseStatusThreshold \
169 ROM_CAPT_getRelNoiseStatusThreshold
170 #else
171 #define MAP_CAPT_getRelNoiseStatusThreshold \
172 CAPT_getRelNoiseStatusThreshold
173 #endif
174
175 // ROM vs. FRAM Calling Macro for CAPT_getMaxRelThreshold()
176 #ifdef ROM_CAPT_getMaxRelThreshold
177 #define MAP_CAPT_getMaxRelThreshold \
178 ROM_CAPT_getMaxRelThreshold
179 #else
180 #define MAP_CAPT_getMaxRelThreshold \
181 CAPT_getMaxRelThreshold
182 #endif
183
184 // ROM vs. FRAM Calling Macro for CAPT_testConversionFrequencyForNoise()
185 #ifdef ROM_CAPT_testConversionFrequencyForNoise
186 #define MAP_CAPT_testConversionFrequencyForNoise \
187 ROM_CAPT_testConversionFrequencyForNoise
188 #else
189 #define MAP_CAPT_testConversionFrequencyForNoise \
190 CAPT_testConversionFrequencyForNoise
191 #endif
192
193 // ROM vs. FRAM Calling Macro for CAPT_correctInvalidMultiFreqCalibration()
194 #ifdef ROM_CAPT_correctInvalidMultiFreqCalibration
195 #define MAP_CAPT_correctInvalidMultiFreqCalibration \
196 ROM_CAPT_correctInvalidMultiFreqCalibration
197 #else
198 #define MAP_CAPT_correctInvalidMultiFreqCalibration \
199 CAPT_correctInvalidMultiFreqCalibration
200 #endif
201
202 // ROM vs. FRAM Calling Macro for CAPT_replaceFrequencyWithError()
203 #ifdef ROM_CAPT_replaceFrequencyWithError
204 #define MAP_CAPT_replaceFrequencyWithError \
205 ROM_CAPT_replaceFrequencyWithError
206 #else
207 #define MAP_CAPT_replaceFrequencyWithError \
208 CAPT_replaceFrequencyWithError
209 #endif
210
211 // ROM vs. FRAM Calling Macro for CAPT_resolveMultiFreqSet()
212 #ifdef ROM_CAPT_resolveMultiFreqSet
213 #define MAP_CAPT_resolveMultiFreqSet \
214 ROM_CAPT_resolveMultiFreqSet
215 #else
216 #define MAP_CAPT_resolveMultiFreqSet \
217 CAPT_resolveMultiFreqSet
218 #endif
219
220 // ROM vs. FRAM Calling Macro for CAPT_computeJitterFilter()
221 #ifdef ROM_CAPT_computeJitterFilter
222 #define MAP_CAPT_computeJitterFilter \
223 ROM_CAPT_computeJitterFilter
224 #else
225 #define MAP_CAPT_computeJitterFilter \
226 CAPT_computeJitterFilter
227 #endif
228
229 // ROM vs. FRAM Calling Macro for CAPT_computePos2ndDegPoly()
230 #ifdef ROM_CAPT_computePos2ndDegPoly
231 #define MAP_CAPT_computePos2ndDegPoly \
232 ROM_CAPT_computePos2ndDegPoly
233 #else
234 #define MAP_CAPT_computePos2ndDegPoly \
235 CAPT_computePos2ndDegPoly
236 #endif
237
238 // ROM vs. FRAM Calling Macro for CAPT_computeRelNoiseComp()
239 #ifdef ROM_CAPT_computeRelNoiseComp
240 #define MAP_CAPT_computeRelNoiseComp \
241 ROM_CAPT_computeRelNoiseComp
242 #else
243 #define MAP_CAPT_computeRelNoiseComp \
244 CAPT_computeRelNoiseComp
245 #endif
246
247 // ROM vs. FRAM Calling Macro for CAPT_computeWheelWrap()
248 #ifdef ROM_CAPT_computeWheelWrap
249 #define MAP_CAPT_computeWheelWrap \
250 ROM_CAPT_computeWheelWrap
251 #else
252 #define MAP_CAPT_computeWheelWrap \
253 CAPT_computeWheelWrap
254 #endif
255
256 // ROM vs. FRAM Calling Macro for CAPT_processSlider()
257 #ifdef ROM_CAPT_processSlider
258 #define MAP_CAPT_processSlider \
259 ROM_CAPT_processSlider
260 #else
261 #define MAP_CAPT_processSlider \
262 CAPT_processSlider
263 #endif
264
265 // ROM vs. FRAM Calling Macro for CAPT_computeArcTanApprox()
266 #ifdef ROM_CAPT_computeArcTanApprox
267 #define MAP_CAPT_computeArcTanApprox \
268 ROM_CAPT_computeArcTanApprox
269 #else
270 #define MAP_CAPT_computeArcTanApprox \
271 CAPT_computeArcTanApprox
272 #endif
273
274 // ROM vs. FRAM Calling Macro for CAPT_computeSliderVectors()
275 #ifdef ROM_CAPT_computeSliderVectors
276 #define MAP_CAPT_computeSliderVectors \
277 ROM_CAPT_computeSliderVectors
278 #else
279 #define MAP_CAPT_computeSliderVectors \
280 CAPT_computeSliderVectors
281 #endif
282
283 // ROM vs. FRAM Calling Macro for CAPT_getSensorPosition()
284 #ifdef ROM_CAPT_getSensorPosition
285 #define MAP_CAPT_getSensorPosition \
286 ROM_CAPT_getSensorPosition
287 #else
288 #define MAP_CAPT_getSensorPosition \
289 CAPT_getSensorPosition
290 #endif
291
292 // ROM vs. FRAM Calling Macro for CAPT_getBeta()
293 #ifdef ROM_CAPT_getBeta
294 #define MAP_CAPT_getBeta \
295 ROM_CAPT_getBeta
296 #else
297 #define MAP_CAPT_getBeta \
298 CAPT_getBeta
299 #endif
300
301 // ROM vs. FRAM Calling Macro for CAPT_getXY()
302 #ifdef ROM_CAPT_getXY
303 #define MAP_CAPT_getXY \
304 ROM_CAPT_getXY
305 #else
306 #define MAP_CAPT_getXY \
307 CAPT_getXY
308 #endif
309
310 // ROM vs. FRAM Calling Macro for CAPT_trimPosition()
311 #ifdef ROM_CAPT_trimPosition
312 #define MAP_CAPT_trimPosition \
313 ROM_CAPT_trimPosition
314 #else
315 #define MAP_CAPT_trimPosition \
316 CAPT_trimPosition
317 #endif
318
319 // ROM vs. FRAM Calling Macro for CAPT_processTrackPadSensor()
320 #ifdef ROM_CAPT_processTrackPadSensor
321 #define MAP_CAPT_processTrackPadSensor \
322 ROM_CAPT_processTrackPadSensor
323 #else
324 #define MAP_CAPT_processTrackPadSensor \
325 CAPT_processTrackPadSensor
326 #endif
327
328 // ROM vs. FRAM Calling Macro for CAPT_processTrackPadGesture()
329 #ifdef ROM_CAPT_processTrackPadGesture
330 #define MAP_CAPT_processTrackPadGesture \
331 ROM_CAPT_processTrackPadGesture
332 #else
333 #define MAP_CAPT_processTrackPadGesture \
334 CAPT_processTrackPadGesture
335 #endif
336
337 // ROM vs. FRAM Calling Macro for CAPT_enableRefCap()
338 #ifdef ROM_CAPT_enableRefCap
339 #define MAP_CAPT_enableRefCap \
340 ROM_CAPT_enableRefCap
341 #else
342 #define MAP_CAPT_enableRefCap \
343 CAPT_enableRefCap
344 #endif
345
346 // ROM vs. FRAM Calling Macro for CAPT_disableRefCap()
347 #ifdef ROM_CAPT_disableRefCap
348 #define MAP_CAPT_disableRefCap \
349 ROM_CAPT_disableRefCap
350 #else
351 #define MAP_CAPT_disableRefCap \
352 CAPT_disableRefCap
353 #endif
354
355 // ROM vs. FRAM Calling Macro for CAPT_powerOn()
356 #ifdef ROM_CAPT_powerOn
357 #define MAP_CAPT_powerOn \
358 ROM_CAPT_powerOn
359 #else
360 #define MAP_CAPT_powerOn \
361 CAPT_powerOn
362 #endif
363
364 // ROM vs. FRAM Calling Macro for CAPT_powerOff()
365 #ifdef ROM_CAPT_powerOff
366 #define MAP_CAPT_powerOff \
367 ROM_CAPT_powerOff
368 #else
369 #define MAP_CAPT_powerOff \
370 CAPT_powerOff
371 #endif
372
373 // ROM vs. FRAM Calling Macro for CAPT_readTimerCompRegister()
374 #ifdef ROM_CAPT_readTimerCompRegister
375 #define MAP_CAPT_readTimerCompRegister \
376 ROM_CAPT_readTimerCompRegister
377 #else
378 #define MAP_CAPT_readTimerCompRegister \
379 CAPT_readTimerCompRegister
380 #endif
381
382 // ROM vs. FRAM Calling Macro for CAPT_writeTimerCompRegister()
383 #ifdef ROM_CAPT_writeTimerCompRegister
384 #define MAP_CAPT_writeTimerCompRegister \
385 ROM_CAPT_writeTimerCompRegister
386 #else
387 #define MAP_CAPT_writeTimerCompRegister \
388 CAPT_writeTimerCompRegister
389 #endif
390
391 // ROM vs. FRAM Calling Macro for CAPT_readTimerRegister()
392 #ifdef ROM_CAPT_readTimerRegister
393 #define MAP_CAPT_readTimerRegister \
394 ROM_CAPT_readTimerRegister
395 #else
396 #define MAP_CAPT_readTimerRegister \
397 CAPT_readTimerRegister
398 #endif
399
400 // ROM vs. FRAM Calling Macro for CAPT_stopTimer()
401 #ifdef ROM_CAPT_stopTimer
402 #define MAP_CAPT_stopTimer \
403 ROM_CAPT_stopTimer
404 #else
405 #define MAP_CAPT_stopTimer \
406 CAPT_stopTimer
407 #endif
408
409 // ROM vs. FRAM Calling Macro for CAPT_startTimer()
410 #ifdef ROM_CAPT_startTimer
411 #define MAP_CAPT_startTimer \
412 ROM_CAPT_startTimer
413 #else
414 #define MAP_CAPT_startTimer \
415 CAPT_startTimer
416 #endif
417
418 // ROM vs. FRAM Calling Macro for CAPT_enableTimerTrigMeasurement()
419 #ifdef ROM_CAPT_enableTimerTrigMeasurement
420 #define MAP_CAPT_enableTimerTrigMeasurement \
421 ROM_CAPT_enableTimerTrigMeasurement
422 #else
423 #define MAP_CAPT_enableTimerTrigMeasurement \
424 CAPT_enableTimerTrigMeasurement
425 #endif
426
427 // ROM vs. FRAM Calling Macro for CAPT_disableTimerTrigMeasurement()
428 #ifdef ROM_CAPT_disableTimerTrigMeasurement
429 #define MAP_CAPT_disableTimerTrigMeasurement \
430 ROM_CAPT_disableTimerTrigMeasurement
431 #else
432 #define MAP_CAPT_disableTimerTrigMeasurement \
433 CAPT_disableTimerTrigMeasurement
434 #endif
435
436 // ROM vs. FRAM Calling Macro for CAPT_clearTimer()
437 #ifdef ROM_CAPT_clearTimer
438 #define MAP_CAPT_clearTimer \
439 ROM_CAPT_clearTimer
440 #else
441 #define MAP_CAPT_clearTimer \
442 CAPT_clearTimer
443 #endif
444
445 // ROM vs. FRAM Calling Macro for CAPT_selectTimerSource()
446 #ifdef ROM_CAPT_selectTimerSource
447 #define MAP_CAPT_selectTimerSource \
448 ROM_CAPT_selectTimerSource
449 #else
450 #define MAP_CAPT_selectTimerSource \
451 CAPT_selectTimerSource
452 #endif
453
454 // ROM vs. FRAM Calling Macro for CAPT_selectTimerSourceDivider()
455 #ifdef ROM_CAPT_selectTimerSourceDivider
456 #define MAP_CAPT_selectTimerSourceDivider \
457 ROM_CAPT_selectTimerSourceDivider
458 #else
459 #define MAP_CAPT_selectTimerSourceDivider \
460 CAPT_selectTimerSourceDivider
461 #endif
462
463 // ROM vs. FRAM Calling Macro for CAPT_startCCounter()
464 #ifdef ROM_CAPT_startCCounter
465 #define MAP_CAPT_startCCounter \
466 ROM_CAPT_startCCounter
467 #else
468 #define MAP_CAPT_startCCounter \
469 CAPT_startCCounter
470 #endif
471
472 // ROM vs. FRAM Calling Macro for CAPT_stopCCounter()
473 #ifdef ROM_CAPT_stopCCounter
474 #define MAP_CAPT_stopCCounter \
475 ROM_CAPT_stopCCounter
476 #else
477 #define MAP_CAPT_stopCCounter \
478 CAPT_stopCCounter
479 #endif
480
481 // ROM vs. FRAM Calling Macro for CAPT_clearCCounter()
482 #ifdef ROM_CAPT_clearCCounter
483 #define MAP_CAPT_clearCCounter \
484 ROM_CAPT_clearCCounter
485 #else
486 #define MAP_CAPT_clearCCounter \
487 CAPT_clearCCounter
488 #endif
489
490 // ROM vs. FRAM Calling Macro for CAPT_selectCCounterInterval()
491 #ifdef ROM_CAPT_selectCCounterInterval
492 #define MAP_CAPT_selectCCounterInterval \
493 ROM_CAPT_selectCCounterInterval
494 #else
495 #define MAP_CAPT_selectCCounterInterval \
496 CAPT_selectCCounterInterval
497 #endif
498
499 // ROM vs. FRAM Calling Macro for CAPT_pollResetStatus()
500 #ifdef ROM_CAPT_pollResetStatus
501 #define MAP_CAPT_pollResetStatus \
502 ROM_CAPT_pollResetStatus
503 #else
504 #define MAP_CAPT_pollResetStatus \
505 CAPT_pollResetStatus
506 #endif
507
508 // ROM vs. FRAM Calling Macro for CAPT_setStabilization()
509 #ifdef ROM_CAPT_setStabilization
510 #define MAP_CAPT_setStabilization \
511 ROM_CAPT_setStabilization
512 #else
513 #define MAP_CAPT_setStabilization \
514 CAPT_setStabilization
515 #endif
516
517 // ROM vs. FRAM Calling Macro for CAPT_releaseStabilization()
518 #ifdef ROM_CAPT_releaseStabilization
519 #define MAP_CAPT_releaseStabilization \
520 ROM_CAPT_releaseStabilization
521 #else
522 #define MAP_CAPT_releaseStabilization \
523 CAPT_releaseStabilization
524 #endif
525
526 // ROM vs. FRAM Calling Macro for CAPT_reset()
527 #ifdef ROM_CAPT_reset
528 #define MAP_CAPT_reset \
529 ROM_CAPT_reset
530 #else
531 #define MAP_CAPT_reset \
532 CAPT_reset
533 #endif
534
535 // ROM vs. FRAM Calling Macro for CAPT_pollCIPF()
536 #ifdef ROM_CAPT_pollCIPF
537 #define MAP_CAPT_pollCIPF \
538 ROM_CAPT_pollCIPF
539 #else
540 #define MAP_CAPT_pollCIPF \
541 CAPT_pollCIPF
542 #endif
543
544 // ROM vs. FRAM Calling Macro for CAPT_init()
545 #ifdef ROM_CAPT_init
546 #define MAP_CAPT_init \
547 ROM_CAPT_init
548 #else
549 #define MAP_CAPT_init \
550 CAPT_init
551 #endif
552
553 // ROM vs. FRAM Calling Macro for CAPT_bypassFSM()
554 #ifdef ROM_CAPT_bypassFSM
555 #define MAP_CAPT_bypassFSM \
556 ROM_CAPT_bypassFSM
557 #else
558 #define MAP_CAPT_bypassFSM \
559 CAPT_bypassFSM
560 #endif
561
562 // ROM vs. FRAM Calling Macro for CAPT_engageFSM()
563 #ifdef ROM_CAPT_engageFSM
564 #define MAP_CAPT_engageFSM \
565 ROM_CAPT_engageFSM
566 #else
567 #define MAP_CAPT_engageFSM \
568 CAPT_engageFSM
569 #endif
570
571 // ROM vs. FRAM Calling Macro for CAPT_writeCoarseGain()
572 #ifdef ROM_CAPT_writeCoarseGain
573 #define MAP_CAPT_writeCoarseGain \
574 ROM_CAPT_writeCoarseGain
575 #else
576 #define MAP_CAPT_writeCoarseGain \
577 CAPT_writeCoarseGain
578 #endif
579
580 // ROM vs. FRAM Calling Macro for CAPT_readCoarseGain()
581 #ifdef ROM_CAPT_readCoarseGain
582 #define MAP_CAPT_readCoarseGain \
583 ROM_CAPT_readCoarseGain
584 #else
585 #define MAP_CAPT_readCoarseGain \
586 CAPT_readCoarseGain
587 #endif
588
589 // ROM vs. FRAM Calling Macro for CAPT_writeFineGain()
590 #ifdef ROM_CAPT_writeFineGain
591 #define MAP_CAPT_writeFineGain \
592 ROM_CAPT_writeFineGain
593 #else
594 #define MAP_CAPT_writeFineGain \
595 CAPT_writeFineGain
596 #endif
597
598 // ROM vs. FRAM Calling Macro for CAPT_readFineGain()
599 #ifdef ROM_CAPT_readFineGain
600 #define MAP_CAPT_readFineGain \
601 ROM_CAPT_readFineGain
602 #else
603 #define MAP_CAPT_readFineGain \
604 CAPT_readFineGain
605 #endif
606
607 // ROM vs. FRAM Calling Macro for CAPT_writeOffsetTap()
608 #ifdef ROM_CAPT_writeOffsetTap
609 #define MAP_CAPT_writeOffsetTap \
610 ROM_CAPT_writeOffsetTap
611 #else
612 #define MAP_CAPT_writeOffsetTap \
613 CAPT_writeOffsetTap
614 #endif
615
616 // ROM vs. FRAM Calling Macro for CAPT_readOffsetTap()
617 #ifdef ROM_CAPT_readOffsetTap
618 #define MAP_CAPT_readOffsetTap \
619 ROM_CAPT_readOffsetTap
620 #else
621 #define MAP_CAPT_readOffsetTap \
622 CAPT_readOffsetTap
623 #endif
624
625 // ROM vs. FRAM Calling Macro for CAPT_readConversion()
626 #ifdef ROM_CAPT_readConversion
627 #define MAP_CAPT_readConversion \
628 ROM_CAPT_readConversion
629 #else
630 #define MAP_CAPT_readConversion \
631 CAPT_readConversion
632 #endif
633
634 // ROM vs. FRAM Calling Macro for CAPT_setCAPLPMCFG()
635 #ifdef ROM_CAPT_setCAPLPMCFG
636 #define MAP_CAPT_setCAPLPMCFG \
637 ROM_CAPT_setCAPLPMCFG
638 #else
639 #define MAP_CAPT_setCAPLPMCFG \
640 CAPT_setCAPLPMCFG
641 #endif
642
643 // ROM vs. FRAM Calling Macro for CAPT_clearCAPLPMCFG()
644 #ifdef ROM_CAPT_clearCAPLPMCFG
645 #define MAP_CAPT_clearCAPLPMCFG \
646 ROM_CAPT_clearCAPLPMCFG
647 #else
648 #define MAP_CAPT_clearCAPLPMCFG \
649 CAPT_clearCAPLPMCFG
650 #endif
651
652 // ROM vs. FRAM Calling Macro for CAPT_setChannelEnable()
653 #ifdef ROM_CAPT_setChannelEnable
654 #define MAP_CAPT_setChannelEnable \
655 ROM_CAPT_setChannelEnable
656 #else
657 #define MAP_CAPT_setChannelEnable \
658 CAPT_setChannelEnable
659 #endif
660
661 // ROM vs. FRAM Calling Macro for CAPT_clearChannelEnable()
662 #ifdef ROM_CAPT_clearChannelEnable
663 #define MAP_CAPT_clearChannelEnable \
664 ROM_CAPT_clearChannelEnable
665 #else
666 #define MAP_CAPT_clearChannelEnable \
667 CAPT_clearChannelEnable
668 #endif
669
670 // ROM vs. FRAM Calling Macro for CAPT_setChannelActive()
671 #ifdef ROM_CAPT_setChannelActive
672 #define MAP_CAPT_setChannelActive \
673 ROM_CAPT_setChannelActive
674 #else
675 #define MAP_CAPT_setChannelActive \
676 CAPT_setChannelActive
677 #endif
678
679 // ROM vs. FRAM Calling Macro for CAPT_clearChannelActive()
680 #ifdef ROM_CAPT_clearChannelActive
681 #define MAP_CAPT_clearChannelActive \
682 ROM_CAPT_clearChannelActive
683 #else
684 #define MAP_CAPT_clearChannelActive \
685 CAPT_clearChannelActive
686 #endif
687
688 // ROM vs. FRAM Calling Macro for CAPT_setChannelOffState()
689 #ifdef ROM_CAPT_setChannelOffState
690 #define MAP_CAPT_setChannelOffState \
691 ROM_CAPT_setChannelOffState
692 #else
693 #define MAP_CAPT_setChannelOffState \
694 CAPT_setChannelOffState
695 #endif
696
697 // ROM vs. FRAM Calling Macro for CAPT_clearChannelOffState()
698 #ifdef ROM_CAPT_clearChannelOffState
699 #define MAP_CAPT_clearChannelOffState \
700 ROM_CAPT_clearChannelOffState
701 #else
702 #define MAP_CAPT_clearChannelOffState \
703 CAPT_clearChannelOffState
704 #endif
705
706 // ROM vs. FRAM Calling Macro for CAPT_setChannelOnState()
707 #ifdef ROM_CAPT_setChannelOnState
708 #define MAP_CAPT_setChannelOnState \
709 ROM_CAPT_setChannelOnState
710 #else
711 #define MAP_CAPT_setChannelOnState \
712 CAPT_setChannelOnState
713 #endif
714
715 // ROM vs. FRAM Calling Macro for CAPT_clearChannelOnState()
716 #ifdef ROM_CAPT_clearChannelOnState
717 #define MAP_CAPT_clearChannelOnState \
718 ROM_CAPT_clearChannelOnState
719 #else
720 #define MAP_CAPT_clearChannelOnState \
721 CAPT_clearChannelOnState
722 #endif
723
724 // ROM vs. FRAM Calling Macro for CAPT_enableSensorIO()
725 #ifdef ROM_CAPT_enableSensorIO
726 #define MAP_CAPT_enableSensorIO \
727 ROM_CAPT_enableSensorIO
728 #else
729 #define MAP_CAPT_enableSensorIO \
730 CAPT_enableSensorIO
731 #endif
732
733 // ROM vs. FRAM Calling Macro for CAPT_disableSensorIO()
734 #ifdef ROM_CAPT_disableSensorIO
735 #define MAP_CAPT_disableSensorIO \
736 ROM_CAPT_disableSensorIO
737 #else
738 #define MAP_CAPT_disableSensorIO \
739 CAPT_disableSensorIO
740 #endif
741
742 // ROM vs. FRAM Calling Macro for CAPT_initSensorIO()
743 #ifdef ROM_CAPT_initSensorIO
744 #define MAP_CAPT_initSensorIO \
745 ROM_CAPT_initSensorIO
746 #else
747 #define MAP_CAPT_initSensorIO \
748 CAPT_initSensorIO
749 #endif
750
751 // ROM vs. FRAM Calling Macro for CAPT_forceSensorIO()
752 #ifdef ROM_CAPT_forceSensorIO
753 #define MAP_CAPT_forceSensorIO \
754 ROM_CAPT_forceSensorIO
755 #else
756 #define MAP_CAPT_forceSensorIO \
757 CAPT_forceSensorIO
758 #endif
759
760 // ROM vs. FRAM Calling Macro for CAPT_applySensorParams()
761 #ifdef ROM_CAPT_applySensorParams
762 #define MAP_CAPT_applySensorParams \
763 ROM_CAPT_applySensorParams
764 #else
765 #define MAP_CAPT_applySensorParams \
766 CAPT_applySensorParams
767 #endif
768
769 // ROM vs. FRAM Calling Macro for CAPT_disableSensorSyncEvent()
770 #ifdef ROM_CAPT_disableSensorSyncEvent
771 #define MAP_CAPT_disableSensorSyncEvent \
772 ROM_CAPT_disableSensorSyncEvent
773 #else
774 #define MAP_CAPT_disableSensorSyncEvent \
775 CAPT_disableSensorSyncEvent
776 #endif
777
778 // ROM vs. FRAM Calling Macro for CAPT_enableSensorSyncEvent()
779 #ifdef ROM_CAPT_enableSensorSyncEvent
780 #define MAP_CAPT_enableSensorSyncEvent \
781 ROM_CAPT_enableSensorSyncEvent
782 #else
783 #define MAP_CAPT_enableSensorSyncEvent \
784 CAPT_enableSensorSyncEvent
785 #endif
786
787 // ROM vs. FRAM Calling Macro for CAPT_applySensorFreq()
788 #ifdef ROM_CAPT_applySensorFreq
789 #define MAP_CAPT_applySensorFreq \
790 ROM_CAPT_applySensorFreq
791 #else
792 #define MAP_CAPT_applySensorFreq \
793 CAPT_applySensorFreq
794 #endif
795
796 // ROM vs. FRAM Calling Macro for CAPT_setCycleIO()
797 #ifdef ROM_CAPT_setCycleIO
798 #define MAP_CAPT_setCycleIO \
799 ROM_CAPT_setCycleIO
800 #else
801 #define MAP_CAPT_setCycleIO \
802 CAPT_setCycleIO
803 #endif
804
805 // ROM vs. FRAM Calling Macro for CAPT_clearCycleIO()
806 #ifdef ROM_CAPT_clearCycleIO
807 #define MAP_CAPT_clearCycleIO \
808 ROM_CAPT_clearCycleIO
809 #else
810 #define MAP_CAPT_clearCycleIO \
811 CAPT_clearCycleIO
812 #endif
813
814 // ROM vs. FRAM Calling Macro for CAPT_applyCycleComp()
815 #ifdef ROM_CAPT_applyCycleComp
816 #define MAP_CAPT_applyCycleComp \
817 ROM_CAPT_applyCycleComp
818 #else
819 #define MAP_CAPT_applyCycleComp \
820 CAPT_applyCycleComp
821 #endif
822
823 // ROM vs. FRAM Calling Macro for CAPT_applyCycleFSM()
824 #ifdef ROM_CAPT_applyCycleFSM
825 #define MAP_CAPT_applyCycleFSM \
826 ROM_CAPT_applyCycleFSM
827 #else
828 #define MAP_CAPT_applyCycleFSM \
829 CAPT_applyCycleFSM
830 #endif
831
832 // ROM vs. FRAM Calling Macro for CAPT_enableISR()
833 #ifdef ROM_CAPT_enableISR
834 #define MAP_CAPT_enableISR \
835 ROM_CAPT_enableISR
836 #else
837 #define MAP_CAPT_enableISR \
838 CAPT_enableISR
839 #endif
840
841 // ROM vs. FRAM Calling Macro for CAPT_disableISR()
842 #ifdef ROM_CAPT_disableISR
843 #define MAP_CAPT_disableISR \
844 ROM_CAPT_disableISR
845 #else
846 #define MAP_CAPT_disableISR \
847 CAPT_disableISR
848 #endif
849
850 // ROM vs. FRAM Calling Macro for CAPT_setCAPSTART()
851 #ifdef ROM_CAPT_setCAPSTART
852 #define MAP_CAPT_setCAPSTART \
853 ROM_CAPT_setCAPSTART
854 #else
855 #define MAP_CAPT_setCAPSTART \
856 CAPT_setCAPSTART
857 #endif
858
859 // ROM vs. FRAM Calling Macro for CAPT_clearCAPSTART()
860 #ifdef ROM_CAPT_clearCAPSTART
861 #define MAP_CAPT_clearCAPSTART \
862 ROM_CAPT_clearCAPSTART
863 #else
864 #define MAP_CAPT_clearCAPSTART \
865 CAPT_clearCAPSTART
866 #endif
867
868 // ROM vs. FRAM Calling Macro for CAPT_saveCycleResults()
869 #ifdef ROM_CAPT_saveCycleResults
870 #define MAP_CAPT_saveCycleResults \
871 ROM_CAPT_saveCycleResults
872 #else
873 #define MAP_CAPT_saveCycleResults \
874 CAPT_saveCycleResults
875 #endif
876
877 // ROM vs. FRAM Calling Macro for CAPT_saveCycleRawResults()
878 #ifdef ROM_CAPT_saveCycleRawResults
879 #define MAP_CAPT_saveCycleRawResults \
880 ROM_CAPT_saveCycleRawResults
881 #else
882 #define MAP_CAPT_saveCycleRawResults \
883 CAPT_saveCycleRawResults
884 #endif
885
886 // ROM vs. FRAM Calling Macro for CAPT_pollIFG()
887 #ifdef ROM_CAPT_pollIFG
888 #define MAP_CAPT_pollIFG \
889 ROM_CAPT_pollIFG
890 #else
891 #define MAP_CAPT_pollIFG \
892 CAPT_pollIFG
893 #endif
894
895 // ROM vs. FRAM Calling Macro for CAPT_clearIFG()
896 #ifdef ROM_CAPT_clearIFG
897 #define MAP_CAPT_clearIFG \
898 ROM_CAPT_clearIFG
899 #else
900 #define MAP_CAPT_clearIFG \
901 CAPT_clearIFG
902 #endif
903
904 // ROM vs. FRAM Calling Macro for CAPT_getInterruptVector()
905 #ifdef ROM_CAPT_getInterruptVector
906 #define MAP_CAPT_getInterruptVector \
907 ROM_CAPT_getInterruptVector
908 #else
909 #define MAP_CAPT_getInterruptVector \
910 CAPT_getInterruptVector
911 #endif
912
913 // ROM vs. FRAM Calling Macro for CAPT_enableShieldIO()
914 #ifdef ROM_CAPT_enableShieldIO
915 #define MAP_CAPT_enableShieldIO \
916 ROM_CAPT_enableShieldIO
917 #else
918 #define MAP_CAPT_enableShieldIO \
919 CAPT_enableShieldIO
920 #endif
921
922 // ROM vs. FRAM Calling Macro for CAPT_disableShieldIO()
923 #ifdef ROM_CAPT_disableShieldIO
924 #define MAP_CAPT_disableShieldIO \
925 ROM_CAPT_disableShieldIO
926 #else
927 #define MAP_CAPT_disableShieldIO \
928 CAPT_disableShieldIO
929 #endif
930
931 // ROM vs. FRAM Calling Macro for CAPT_initSensor()
932 #ifdef ROM_CAPT_initSensor
933 #define MAP_CAPT_initSensor \
934 ROM_CAPT_initSensor
935 #else
936 #define MAP_CAPT_initSensor \
937 CAPT_initSensor
938 #endif
939
940 // ROM vs. FRAM Calling Macro for CAPT_updateSensor()
941 #ifdef ROM_CAPT_updateSensor
942 #define MAP_CAPT_updateSensor \
943 ROM_CAPT_updateSensor
944 #else
945 #define MAP_CAPT_updateSensor \
946 CAPT_updateSensor
947 #endif
948
949 // ROM vs. FRAM Calling Macro for CAPT_updateSensorRawCount()
950 #ifdef ROM_CAPT_updateSensorRawCount
951 #define MAP_CAPT_updateSensorRawCount \
952 ROM_CAPT_updateSensorRawCount
953 #else
954 #define MAP_CAPT_updateSensorRawCount \
955 CAPT_updateSensorRawCount
956 #endif
957
958 // ROM vs. FRAM Calling Macro for CAPT_startWakeOnProxMode()
959 #ifdef ROM_CAPT_startWakeOnProxMode
960 #define MAP_CAPT_startWakeOnProxMode \
961 ROM_CAPT_startWakeOnProxMode
962 #else
963 #define MAP_CAPT_startWakeOnProxMode \
964 CAPT_startWakeOnProxMode
965 #endif
966
967 // ROM vs. FRAM Calling Macro for CAPT_stopWakeOnProxMode()
968 #ifdef ROM_CAPT_stopWakeOnProxMode
969 #define MAP_CAPT_stopWakeOnProxMode \
970 ROM_CAPT_stopWakeOnProxMode
971 #else
972 #define MAP_CAPT_stopWakeOnProxMode \
973 CAPT_stopWakeOnProxMode
974 #endif
975
976 // ROM vs. FRAM Calling Macro for CAPT_processFSMCycle()
977 #ifdef ROM_CAPT_processFSMCycle
978 #define MAP_CAPT_processFSMCycle \
979 ROM_CAPT_processFSMCycle
980 #else
981 #define MAP_CAPT_processFSMCycle \
982 CAPT_processFSMCycle
983 #endif
984
985 // ROM vs. FRAM Calling Macro for CAPT_preProcessSlider()
986 #ifdef ROM_CAPT_preProcessSlider
987 #define MAP_CAPT_preProcessSlider \
988 ROM_CAPT_preProcessSlider
989 #else
990 #define MAP_CAPT_preProcessSlider \
991 CAPT_preProcessSlider
992 #endif
993
994 // ROM vs. FRAM Calling Macro for CAPT_processSensor()
995 #ifdef ROM_CAPT_processSensor
996 #define MAP_CAPT_processSensor \
997 ROM_CAPT_processSensor
998 #else
999 #define MAP_CAPT_processSensor \
1000 CAPT_processSensor
1001 #endif
1002
1003 // ROM vs. FRAM Calling Macro for CAPT_testForRecalibration()
1004 #ifdef ROM_CAPT_testForRecalibration
1005 #define MAP_CAPT_testForRecalibration \
1006 ROM_CAPT_testForRecalibration
1007 #else
1008 #define MAP_CAPT_testForRecalibration \
1009 CAPT_testForRecalibration
1010 #endif
1011
1012 // ROM vs. FRAM Calling Macro for CAPT_testForMaxCountRecalibration()
1013 #ifdef ROM_CAPT_testForMaxCountRecalibration
1014 #define MAP_CAPT_testForMaxCountRecalibration \
1015 ROM_CAPT_testForMaxCountRecalibration
1016 #else
1017 #define MAP_CAPT_testForMaxCountRecalibration \
1018 CAPT_testForMaxCountRecalibration
1019 #endif
1020
1021 // ROM vs. FRAM Calling Macro for CAPT_testForNegativeTouchRecalibration()
1022 #ifdef ROM_CAPT_testForNegativeTouchRecalibration
1023 #define MAP_CAPT_testForNegativeTouchRecalibration \
1024 ROM_CAPT_testForNegativeTouchRecalibration
1025 #else
1026 #define MAP_CAPT_testForNegativeTouchRecalibration \
1027 CAPT_testForNegativeTouchRecalibration
1028 #endif
1029
1030 // ROM vs. FRAM Calling Macro for CAPT_flagAllElementsForReseed()
1031 #ifdef ROM_CAPT_flagAllElementsForReseed
1032 #define MAP_CAPT_flagAllElementsForReseed \
1033 ROM_CAPT_flagAllElementsForReseed
1034 #else
1035 #define MAP_CAPT_flagAllElementsForReseed \
1036 CAPT_flagAllElementsForReseed
1037 #endif
1038
1039 // ROM vs. FRAM Calling Macro for CAPT_updateSensorTimeout()
1040 #ifdef ROM_CAPT_updateSensorTimeout
1041 #define MAP_CAPT_updateSensorTimeout \
1042 ROM_CAPT_updateSensorTimeout
1043 #else
1044 #define MAP_CAPT_updateSensorTimeout \
1045 CAPT_updateSensorTimeout
1046 #endif
1047
1048 // ROM vs. FRAM Calling Macro for CAPT_updateSensorNoise()
1049 #ifdef ROM_CAPT_updateSensorNoise
1050 #define MAP_CAPT_updateSensorNoise \
1051 ROM_CAPT_updateSensorNoise
1052 #else
1053 #define MAP_CAPT_updateSensorNoise \
1054 CAPT_updateSensorNoise
1055 #endif
1056
1057 // ROM vs. FRAM Calling Macro for CAPT_convertAbsToRel()
1058 #ifdef ROM_CAPT_convertAbsToRel
1059 #define MAP_CAPT_convertAbsToRel \
1060 ROM_CAPT_convertAbsToRel
1061 #else
1062 #define MAP_CAPT_convertAbsToRel \
1063 CAPT_convertAbsToRel
1064 #endif
1065
1066 // ROM vs. FRAM Calling Macro for CAPT_convertRelToAbs()
1067 #ifdef ROM_CAPT_convertRelToAbs
1068 #define MAP_CAPT_convertRelToAbs \
1069 ROM_CAPT_convertRelToAbs
1070 #else
1071 #define MAP_CAPT_convertRelToAbs \
1072 CAPT_convertRelToAbs
1073 #endif
1074
1075 // ROM vs. FRAM Calling Macro for CAPT_getElementStateBitField()
1076 #ifdef ROM_CAPT_getElementStateBitField
1077 #define MAP_CAPT_getElementStateBitField \
1078 ROM_CAPT_getElementStateBitField
1079 #else
1080 #define MAP_CAPT_getElementStateBitField \
1081 CAPT_getElementStateBitField
1082 #endif
1083
1084 // ROM vs. FRAM Calling Macro for CAPT_updateFilterCounts()
1085 #ifdef ROM_CAPT_updateFilterCounts
1086 #define MAP_CAPT_updateFilterCounts \
1087 ROM_CAPT_updateFilterCounts
1088 #else
1089 #define MAP_CAPT_updateFilterCounts \
1090 CAPT_updateFilterCounts
1091 #endif
1092
1093 // ROM vs. FRAM Calling Macro for CAPT_updateFSMTouch()
1094 #ifdef ROM_CAPT_updateFSMTouch
1095 #define MAP_CAPT_updateFSMTouch \
1096 ROM_CAPT_updateFSMTouch
1097 #else
1098 #define MAP_CAPT_updateFSMTouch \
1099 CAPT_updateFSMTouch
1100 #endif
1101
1102 // ROM vs. FRAM Calling Macro for CAPT_updateFSMProx()
1103 #ifdef ROM_CAPT_updateFSMProx
1104 #define MAP_CAPT_updateFSMProx \
1105 ROM_CAPT_updateFSMProx
1106 #else
1107 #define MAP_CAPT_updateFSMProx \
1108 CAPT_updateFSMProx
1109 #endif
1110
1111 // ROM vs. FRAM Calling Macro for CAPT_updateProx()
1112 #ifdef ROM_CAPT_updateProx
1113 #define MAP_CAPT_updateProx \
1114 ROM_CAPT_updateProx
1115 #else
1116 #define MAP_CAPT_updateProx \
1117 CAPT_updateProx
1118 #endif
1119
1120 // ROM vs. FRAM Calling Macro for CAPT_updateTouch()
1121 #ifdef ROM_CAPT_updateTouch
1122 #define MAP_CAPT_updateTouch \
1123 ROM_CAPT_updateTouch
1124 #else
1125 #define MAP_CAPT_updateTouch \
1126 CAPT_updateTouch
1127 #endif
1128
1129 // ROM vs. FRAM Calling Macro for CAPT_updateLTA()
1130 #ifdef ROM_CAPT_updateLTA
1131 #define MAP_CAPT_updateLTA \
1132 ROM_CAPT_updateLTA
1133 #else
1134 #define MAP_CAPT_updateLTA \
1135 CAPT_updateLTA
1136 #endif
1137
1138 // ROM vs. FRAM Calling Macro for CAPT_clearSensorProxTouch()
1139 #ifdef ROM_CAPT_clearSensorProxTouch
1140 #define MAP_CAPT_clearSensorProxTouch \
1141 ROM_CAPT_clearSensorProxTouch
1142 #else
1143 #define MAP_CAPT_clearSensorProxTouch \
1144 CAPT_clearSensorProxTouch
1145 #endif
1146
1147 // ROM vs. FRAM Calling Macro for CAPT_updateSensorProxTouch()
1148 #ifdef ROM_CAPT_updateSensorProxTouch
1149 #define MAP_CAPT_updateSensorProxTouch \
1150 ROM_CAPT_updateSensorProxTouch
1151 #else
1152 #define MAP_CAPT_updateSensorProxTouch \
1153 CAPT_updateSensorProxTouch
1154 #endif
1155
1156 // ROM vs. FRAM Calling Macro for CAPT_updateFilterCount()
1157 #ifdef ROM_CAPT_updateFilterCount
1158 #define MAP_CAPT_updateFilterCount \
1159 ROM_CAPT_updateFilterCount
1160 #else
1161 #define MAP_CAPT_updateFilterCount \
1162 CAPT_updateFilterCount
1163 #endif
1164
1165 // ROM vs. FRAM Calling Macro for CAPT_computeIIRFilter()
1166 #ifdef ROM_CAPT_computeIIRFilter
1167 #define MAP_CAPT_computeIIRFilter \
1168 ROM_CAPT_computeIIRFilter
1169 #else
1170 #define MAP_CAPT_computeIIRFilter \
1171 CAPT_computeIIRFilter
1172 #endif
1173
1174 // ROM vs. FRAM Calling Macro for CAPT_computeIIRFilterFast()
1175 #ifdef ROM_CAPT_computeIIRFilterFast
1176 #define MAP_CAPT_computeIIRFilterFast \
1177 ROM_CAPT_computeIIRFilterFast
1178 #else
1179 #define MAP_CAPT_computeIIRFilterFast \
1180 CAPT_computeIIRFilterFast
1181 #endif
1182
1183 // ROM vs. FRAM Calling Macro for CAPT_registerCallback()
1184 #ifdef ROM_CAPT_registerCallback
1185 #define MAP_CAPT_registerCallback \
1186 ROM_CAPT_registerCallback
1187 #else
1188 #define MAP_CAPT_registerCallback \
1189 CAPT_registerCallback
1190 #endif
1191
1192 // ROM vs. FRAM Calling Macro for CAPT_reseedFilter()
1193 #ifdef ROM_CAPT_reseedFilter
1194 #define MAP_CAPT_reseedFilter \
1195 ROM_CAPT_reseedFilter
1196 #else
1197 #define MAP_CAPT_reseedFilter \
1198 CAPT_reseedFilter
1199 #endif
1200
1201 // ROM vs. FRAM Calling Macro for CAPT_reseedFilterAll()
1202 #ifdef ROM_CAPT_reseedFilterAll
1203 #define MAP_CAPT_reseedFilterAll \
1204 ROM_CAPT_reseedFilterAll
1205 #else
1206 #define MAP_CAPT_reseedFilterAll \
1207 CAPT_reseedFilterAll
1208 #endif
1209
1210 // ROM vs. FRAM Calling Macro for CAPT_blockOnFlag()
1211 #ifdef ROM_CAPT_blockOnFlag
1212 #define MAP_CAPT_blockOnFlag \
1213 ROM_CAPT_blockOnFlag
1214 #else
1215 #define MAP_CAPT_blockOnFlag \
1216 CAPT_blockOnFlag
1217 #endif
1218
1219 // ROM vs. FRAM Calling Macro for CAPT_loadCycle()
1220 #ifdef ROM_CAPT_loadCycle
1221 #define MAP_CAPT_loadCycle \
1222 ROM_CAPT_loadCycle
1223 #else
1224 #define MAP_CAPT_loadCycle \
1225 CAPT_loadCycle
1226 #endif
1227
1228 // ROM vs. FRAM Calling Macro for CAPT_unloadCycle()
1229 #ifdef ROM_CAPT_unloadCycle
1230 #define MAP_CAPT_unloadCycle \
1231 ROM_CAPT_unloadCycle
1232 #else
1233 #define MAP_CAPT_unloadCycle \
1234 CAPT_unloadCycle
1235 #endif
1236
1237 // ROM vs. FRAM Calling Macro for CAPT_startConversion()
1238 #ifdef ROM_CAPT_startConversion
1239 #define MAP_CAPT_startConversion \
1240 ROM_CAPT_startConversion
1241 #else
1242 #define MAP_CAPT_startConversion \
1243 CAPT_startConversion
1244 #endif
1245
1246 // ROM vs. FRAM Calling Macro for CAPT_cleanupAfterConversion()
1247 #ifdef ROM_CAPT_cleanupAfterConversion
1248 #define MAP_CAPT_cleanupAfterConversion \
1249 ROM_CAPT_cleanupAfterConversion
1250 #else
1251 #define MAP_CAPT_cleanupAfterConversion \
1252 CAPT_cleanupAfterConversion
1253 #endif
1254
1255 // ROM vs. FRAM Calling Macro for CAPT_startConversionAndWaitUntilDone()
1256 #ifdef ROM_CAPT_startConversionAndWaitUntilDone
1257 #define MAP_CAPT_startConversionAndWaitUntilDone \
1258 ROM_CAPT_startConversionAndWaitUntilDone
1259 #else
1260 #define MAP_CAPT_startConversionAndWaitUntilDone \
1261 CAPT_startConversionAndWaitUntilDone
1262 #endif
1263
1264 // ROM vs. FRAM Calling Macro for CAPT_updateSensorWithEMC()
1265 #ifdef ROM_CAPT_updateSensorWithEMC
1266 #define MAP_CAPT_updateSensorWithEMC \
1267 ROM_CAPT_updateSensorWithEMC
1268 #else
1269 #define MAP_CAPT_updateSensorWithEMC \
1270 CAPT_updateSensorWithEMC
1271 #endif
1272
1273 // ROM vs. FRAM Calling Macro for CAPT_processCycleWithEMC()
1274 #ifdef ROM_CAPT_processCycleWithEMC
1275 #define MAP_CAPT_processCycleWithEMC \
1276 ROM_CAPT_processCycleWithEMC
1277 #else
1278 #define MAP_CAPT_processCycleWithEMC \
1279 CAPT_processCycleWithEMC
1280 #endif
1281
1282 // ROM vs. FRAM Calling Macro for CAPT_updateElementFilteredValuesWithEMC()
1283 #ifdef ROM_CAPT_updateElementFilteredValuesWithEMC
1284 #define MAP_CAPT_updateElementFilteredValuesWithEMC \
1285 ROM_CAPT_updateElementFilteredValuesWithEMC
1286 #else
1287 #define MAP_CAPT_updateElementFilteredValuesWithEMC \
1288 CAPT_updateElementFilteredValuesWithEMC
1289 #endif
1290
1291 // ROM vs. FRAM Calling Macro for CAPT_updateSelfElementProxTouchWithEMC()
1292 #ifdef ROM_CAPT_updateSelfElementProxTouchWithEMC
1293 #define MAP_CAPT_updateSelfElementProxTouchWithEMC \
1294 ROM_CAPT_updateSelfElementProxTouchWithEMC
1295 #else
1296 #define MAP_CAPT_updateSelfElementProxTouchWithEMC \
1297 CAPT_updateSelfElementProxTouchWithEMC
1298 #endif
1299
1300 // ROM vs. FRAM Calling Macro for CAPT_updateProjElementProxTouchWithEMC()
1301 #ifdef ROM_CAPT_updateProjElementProxTouchWithEMC
1302 #define MAP_CAPT_updateProjElementProxTouchWithEMC \
1303 ROM_CAPT_updateProjElementProxTouchWithEMC
1304 #else
1305 #define MAP_CAPT_updateProjElementProxTouchWithEMC \
1306 CAPT_updateProjElementProxTouchWithEMC
1307 #endif
1308
1309 // ROM vs. FRAM Calling Macro for CAPT_registerTrackPadSensorProcessing()
1310 #ifdef ROM_CAPT_registerTrackPadSensorProcessing
1311 #define MAP_CAPT_registerTrackPadSensorProcessing \
1312 ROM_CAPT_registerTrackPadSensorProcessing
1313 #else
1314 #define MAP_CAPT_registerTrackPadSensorProcessing \
1315 CAPT_registerTrackPadSensorProcessing
1316 #endif
1317
1318 // ROM vs. FRAM Calling Macro for CAPT_registerTrackPadGestureProcessing()
1319 #ifdef ROM_CAPT_registerTrackPadGestureProcessing
1320 #define MAP_CAPT_registerTrackPadGestureProcessing \
1321 ROM_CAPT_registerTrackPadGestureProcessing
1322 #else
1323 #define MAP_CAPT_registerTrackPadGestureProcessing \
1324 CAPT_registerTrackPadGestureProcessing
1325 #endif
1326
1327 // ROM vs. FRAM Calling Macro for CAPT_initByteQueue()
1328 #ifdef ROM_CAPT_initByteQueue
1329 #define MAP_CAPT_initByteQueue \
1330 ROM_CAPT_initByteQueue
1331 #else
1332 #define MAP_CAPT_initByteQueue \
1333 CAPT_initByteQueue
1334 #endif
1335
1336 // ROM vs. FRAM Calling Macro for CAPT_pushOntoByteQueue()
1337 #ifdef ROM_CAPT_pushOntoByteQueue
1338 #define MAP_CAPT_pushOntoByteQueue \
1339 ROM_CAPT_pushOntoByteQueue
1340 #else
1341 #define MAP_CAPT_pushOntoByteQueue \
1342 CAPT_pushOntoByteQueue
1343 #endif
1344
1345 // ROM vs. FRAM Calling Macro for CAPT_pullFromByteQueue()
1346 #ifdef ROM_CAPT_pullFromByteQueue
1347 #define MAP_CAPT_pullFromByteQueue \
1348 ROM_CAPT_pullFromByteQueue
1349 #else
1350 #define MAP_CAPT_pullFromByteQueue \
1351 CAPT_pullFromByteQueue
1352 #endif
1353
1354 // ROM vs. FRAM Calling Macro for CAPT_getByteQueueSize()
1355 #ifdef ROM_CAPT_getByteQueueSize
1356 #define MAP_CAPT_getByteQueueSize \
1357 ROM_CAPT_getByteQueueSize
1358 #else
1359 #define MAP_CAPT_getByteQueueSize \
1360 CAPT_getByteQueueSize
1361 #endif
1362
1363 // ROM vs. FRAM Calling Macro for CAPT_isByteQueueFull()
1364 #ifdef ROM_CAPT_isByteQueueFull
1365 #define MAP_CAPT_isByteQueueFull \
1366 ROM_CAPT_isByteQueueFull
1367 #else
1368 #define MAP_CAPT_isByteQueueFull \
1369 CAPT_isByteQueueFull
1370 #endif
1371
1372 // ROM vs. FRAM Calling Macro for CAPT_isByteQueueEmpty()
1373 #ifdef ROM_CAPT_isByteQueueEmpty
1374 #define MAP_CAPT_isByteQueueEmpty \
1375 ROM_CAPT_isByteQueueEmpty
1376 #else
1377 #define MAP_CAPT_isByteQueueEmpty \
1378 CAPT_isByteQueueEmpty
1379 #endif
1380
1381 // ROM vs. FRAM Calling Macro for CAPT_initPingPongBuffer()
1382 #ifdef ROM_CAPT_initPingPongBuffer
1383 #define MAP_CAPT_initPingPongBuffer \
1384 ROM_CAPT_initPingPongBuffer
1385 #else
1386 #define MAP_CAPT_initPingPongBuffer \
1387 CAPT_initPingPongBuffer
1388 #endif
1389
1390 // ROM vs. FRAM Calling Macro for CAPT_togglePingPongBuffer()
1391 #ifdef ROM_CAPT_togglePingPongBuffer
1392 #define MAP_CAPT_togglePingPongBuffer \
1393 ROM_CAPT_togglePingPongBuffer
1394 #else
1395 #define MAP_CAPT_togglePingPongBuffer \
1396 CAPT_togglePingPongBuffer
1397 #endif
1398
1399 // ROM vs. FRAM Calling Macro for CAPT_getGeneralPurposePacket()
1400 #ifdef ROM_CAPT_getGeneralPurposePacket
1401 #define MAP_CAPT_getGeneralPurposePacket \
1402 ROM_CAPT_getGeneralPurposePacket
1403 #else
1404 #define MAP_CAPT_getGeneralPurposePacket \
1405 CAPT_getGeneralPurposePacket
1406 #endif
1407
1408 // ROM vs. FRAM Calling Macro for CAPT_getStringPacket()
1409 #ifdef ROM_CAPT_getStringPacket
1410 #define MAP_CAPT_getStringPacket \
1411 ROM_CAPT_getStringPacket
1412 #else
1413 #define MAP_CAPT_getStringPacket \
1414 CAPT_getStringPacket
1415 #endif
1416
1417 // ROM vs. FRAM Calling Macro for CAPT_getTrackPadPacket()
1418 #ifdef ROM_CAPT_getTrackPadPacket
1419 #define MAP_CAPT_getTrackPadPacket \
1420 ROM_CAPT_getTrackPadPacket
1421 #else
1422 #define MAP_CAPT_getTrackPadPacket \
1423 CAPT_getTrackPadPacket
1424 #endif
1425
1426 // ROM vs. FRAM Calling Macro for CAPT_accessSpecialSensorParameter()
1427 #ifdef ROM_CAPT_accessSpecialSensorParameter
1428 #define MAP_CAPT_accessSpecialSensorParameter \
1429 ROM_CAPT_accessSpecialSensorParameter
1430 #else
1431 #define MAP_CAPT_accessSpecialSensorParameter \
1432 CAPT_accessSpecialSensorParameter
1433 #endif
1434
1435 // ROM vs. FRAM Calling Macro for CAPT_getCyclePacket()
1436 #ifdef ROM_CAPT_getCyclePacket
1437 #define MAP_CAPT_getCyclePacket \
1438 ROM_CAPT_getCyclePacket
1439 #else
1440 #define MAP_CAPT_getCyclePacket \
1441 CAPT_getCyclePacket
1442 #endif
1443
1444 // ROM vs. FRAM Calling Macro for CAPT_getSensorPacket()
1445 #ifdef ROM_CAPT_getSensorPacket
1446 #define MAP_CAPT_getSensorPacket \
1447 ROM_CAPT_getSensorPacket
1448 #else
1449 #define MAP_CAPT_getSensorPacket \
1450 CAPT_getSensorPacket
1451 #endif
1452
1453 // ROM vs. FRAM Calling Macro for CAPT_getChecksum()
1454 #ifdef ROM_CAPT_getChecksum
1455 #define MAP_CAPT_getChecksum \
1456 ROM_CAPT_getChecksum
1457 #else
1458 #define MAP_CAPT_getChecksum \
1459 CAPT_getChecksum
1460 #endif
1461
1462 // ROM vs. FRAM Calling Macro for CAPT_verifyChecksum()
1463 #ifdef ROM_CAPT_verifyChecksum
1464 #define MAP_CAPT_verifyChecksum \
1465 ROM_CAPT_verifyChecksum
1466 #else
1467 #define MAP_CAPT_verifyChecksum \
1468 CAPT_verifyChecksum
1469 #endif
1470
1471 // ROM vs. FRAM Calling Macro for CAPT_stuffSyncBytes()
1472 #ifdef ROM_CAPT_stuffSyncBytes
1473 #define MAP_CAPT_stuffSyncBytes \
1474 ROM_CAPT_stuffSyncBytes
1475 #else
1476 #define MAP_CAPT_stuffSyncBytes \
1477 CAPT_stuffSyncBytes
1478 #endif
1479
1480 // ROM vs. FRAM Calling Macro for CAPT_processReceivedData()
1481 #ifdef ROM_CAPT_processReceivedData
1482 #define MAP_CAPT_processReceivedData \
1483 ROM_CAPT_processReceivedData
1484 #else
1485 #define MAP_CAPT_processReceivedData \
1486 CAPT_processReceivedData
1487 #endif
1488
1489 // ROM vs. FRAM Calling Macro for CAPT_accessSensorParameter()
1490 #ifdef ROM_CAPT_accessSensorParameter
1491 #define MAP_CAPT_accessSensorParameter \
1492 ROM_CAPT_accessSensorParameter
1493 #else
1494 #define MAP_CAPT_accessSensorParameter \
1495 CAPT_accessSensorParameter
1496 #endif
1497
1498 // ROM vs. FRAM Calling Macro for CAPT_accessTrackPadSensorParameter()
1499 #ifdef ROM_CAPT_accessTrackPadSensorParameter
1500 #define MAP_CAPT_accessTrackPadSensorParameter \
1501 ROM_CAPT_accessTrackPadSensorParameter
1502 #else
1503 #define MAP_CAPT_accessTrackPadSensorParameter \
1504 CAPT_accessTrackPadSensorParameter
1505 #endif
1506
1507 // ROM vs. FRAM Calling Macro for CAPT_getTrackPadSensorStatusPacket()
1508 #ifdef ROM_CAPT_getTrackPadSensorStatusPacket
1509 #define MAP_CAPT_getTrackPadSensorStatusPacket \
1510 ROM_CAPT_getTrackPadSensorStatusPacket
1511 #else
1512 #define MAP_CAPT_getTrackPadSensorStatusPacket \
1513 CAPT_getTrackPadSensorStatusPacket
1514 #endif
1515
1516 // ROM vs. FRAM Calling Macro for CAPT_initUI()
1517 #ifdef ROM_CAPT_initUI
1518 #define MAP_CAPT_initUI \
1519 ROM_CAPT_initUI
1520 #else
1521 #define MAP_CAPT_initUI \
1522 CAPT_initUI
1523 #endif
1524
1525 // ROM vs. FRAM Calling Macro for CAPT_calibrateUI()
1526 #ifdef ROM_CAPT_calibrateUI
1527 #define MAP_CAPT_calibrateUI \
1528 ROM_CAPT_calibrateUI
1529 #else
1530 #define MAP_CAPT_calibrateUI \
1531 CAPT_calibrateUI
1532 #endif
1533
1534 // ROM vs. FRAM Calling Macro for CAPT_updateUI()
1535 #ifdef ROM_CAPT_updateUI
1536 #define MAP_CAPT_updateUI \
1537 ROM_CAPT_updateUI
1538 #else
1539 #define MAP_CAPT_updateUI \
1540 CAPT_updateUI
1541 #endif
1542
1543 // ROM vs. FRAM Calling Macro for CAPT_getGlobalUIProximityStatus()
1544 #ifdef ROM_CAPT_getGlobalUIProximityStatus
1545 #define MAP_CAPT_getGlobalUIProximityStatus \
1546 ROM_CAPT_getGlobalUIProximityStatus
1547 #else
1548 #define MAP_CAPT_getGlobalUIProximityStatus \
1549 CAPT_getGlobalUIProximityStatus
1550 #endif
1551
1552 // ROM vs. FRAM Calling Macro for CAPT_ISR()
1553 #ifdef ROM_CAPT_ISR
1554 #define MAP_CAPT_ISR \
1555 ROM_CAPT_ISR
1556 #else
1557 #define MAP_CAPT_ISR \
1558 CAPT_ISR
1559 #endif
1560
1561 #endif // __ROM_MAP_CAPTIVATE_H__

© Copyright 1995-2018, Texas Instruments Incorporated. All rights reserved.
Trademarks | Privacy policy | Terms of use | Terms of sale