source/adc.c

   1 /** @file adc.c \r
   2 *   @brief ADC Driver Source File\r
   3 *   @date 04.January.2012\r
   4 *   @version 03.01.00\r
   5 *\r
   6 *   This file contains:\r
   7 *   - API Funcions\r
   8 *   - Interrupt Handlers\r
   9 *   .\r
  10 *   which are relevant for the ADC driver.\r
  11 */\r
  12 \r
  13 /* (c) Texas Instruments 2009-2012, All rights reserved. */\r
  14 \r
  15 /* USER CODE BEGIN (0) */\r
  16 /* USER CODE END */\r
  17 \r
  18 /* Include Files */\r
  19 \r
  20 #include "adc.h"\r
  21 \r
  22 /* USER CODE BEGIN (1) */\r
  23 /* USER CODE END */\r
  24 \r
  25 \r
  26 /** @fn void adcInit(void)\r
  27 *   @brief Initializes ADC Driver\r
  28 *\r
  29 *   This function initializes the ADC driver.\r
  30 *\r
  31 */\r
  32 \r
  33 /* USER CODE BEGIN (2) */\r
  34 /* USER CODE END */\r
  35 \r
  36 void adcInit(void)\r
  37 {\r
  38 /* USER CODE BEGIN (3) */\r
  39 /* USER CODE END */\r
  40 \r
  41 \r
  42 \r
  43     /** @b Initialize @b ADC1: */\r
  44 \r
  45     /** - Reset ADC module */\r
  46     adcREG1->RSTCR = 1U;\r
  47     adcREG1->RSTCR = 0U;\r
  48 \r
  49     /** - Enable 12-BIT ADC  */\r
  50     adcREG1->OPMODECR |= 0x80000000U;\r
  51         \r
  52     /** - Setup prescaler */\r
  53     adcREG1->CLOCKCR = 7U;\r
  54  \r
  55     /** - Setup memory boundaries */\r
  56     adcREG1->BNDCR  =(8U << 16U)|(8U + 8U);\r
  57     adcREG1->BNDEND = 2U;\r
  58  \r
  59     /** - Setup event group conversion mode\r
  60     *     - Setup data format\r
  61     *     - Enable/Disable channel id in conversion result\r
  62     *     - Enable/Disable continuous conversion\r
  63     */\r
  64     adcREG1->GxMODECR[0U] = ADC_12_BIT\r
  65                           | 0x00000000U\r
  66                           | 0x00000000U;\r
  67 \r
  68     /** - Setup event group hardware trigger\r
  69      *     - Setup hardware trigger edge\r
  70      *     - Setup hardware trigger source\r
  71      */\r
  72     adcREG1->G0SRC = 0x00000000U\r
  73                    | ADC1_EVENT;\r
  74 \r
  75     /** - Setup event group sample window */\r
  76     adcREG1->G0SAMP = 0U;\r
  77 \r
  78     /** - Setup event group sample discharge \r
  79     *     - Setup discharge prescaler\r
  80     *     - Enable/Disable discharge\r
  81     */\r
  82     adcREG1->G0SAMPDISEN = 0U << 8U\r
  83                          | 0x00000000U;\r
  84 \r
  85     /** - Setup group 1 conversion mode\r
  86     *     - Setup data format\r
  87     *     - Enable/Disable channel id in conversion result\r
  88     *     - Enable/Disable continuous conversion\r
  89     */\r
  90     adcREG1->GxMODECR[1U] = ADC_12_BIT\r
  91                           | 0x00000020U\r
  92                           | 0x00000000U\r
  93                           | 0x00000000U;\r
  94 \r
  95     /** - Setup group 1 hardware trigger\r
  96      *     - Setup hardware trigger edge\r
  97      *     - Setup hardware trigger source\r
  98      */\r
  99     adcREG1->G1SRC = 0x00000000U\r
 100                    | ADC1_EVENT;\r
 101 \r
 102     /** - Setup group 1 sample window */\r
 103     adcREG1->G1SAMP = 0U;\r
 104 \r
 105     /** - Setup group 1 sample discharge \r
 106     *     - Setup discharge prescaler\r
 107     *     - Enable/Disable discharge\r
 108     */\r
 109     adcREG1->G1SAMPDISEN = 0U << 8U\r
 110                          | 0x00000000U;\r
 111 \r
 112     /** - Setup group 2 conversion mode\r
 113      *     - Setup data format\r
 114      *     - Enable/Disable channel id in conversion result\r
 115      *     - Enable/Disable continuous conversion\r
 116      */\r
 117     adcREG1->GxMODECR[2U] = ADC_12_BIT\r
 118                           | 0x00000000U\r
 119                           | 0x00000000U\r
 120                           | 0x00000000U;\r
 121 \r
 122     /** - Setup group 2 hardware trigger\r
 123         *     - Setup hardware trigger edge\r
 124     *     - Setup hardware trigger source\r
 125         */\r
 126     adcREG1->G2SRC = 0x00000000U\r
 127                    | ADC1_EVENT;\r
 128 \r
 129     /** - Setup group 2 sample window */\r
 130     adcREG1->G2SAMP = 0U;\r
 131 \r
 132     /** - Setup group 2 sample discharge \r
 133     *     - Setup discharge prescaler\r
 134     *     - Enable/Disable discharge\r
 135     */\r
 136     adcREG1->G2SAMPDISEN = 0U << 8U\r
 137                          | 0x00000000U;\r
 138 \r
 139     /** - Enable ADC module */\r
 140     adcREG1->OPMODECR |= 0x80140001U;\r
 141 \r
 142     /** - Wait for buffer inialisation complete */\r
 143     while ((adcREG1->BUFINIT) != 0) { /* Wait */ } \r
 144     \r
 145     /** - Setup parity */\r
 146     adcREG1->PARCR = 0x00000005U;\r
 147 \r
 148 \r
 149 /* USER CODE BEGIN (4) */\r
 150 /* USER CODE END */\r
 151 }\r
 152 \r
 153 /* USER CODE BEGIN (5) */\r
 154 /* USER CODE END */\r
 155 \r
 156 \r
 157 /** @fn void adcStartConversion(adcBASE_t *adc, uint32_t group)\r
 158 *   @brief Starts an ADC conversion\r
 159 *   @param[in] adc Pointer to ADC module:\r
 160 *              - adcREG1: ADC1 module pointer\r
 161 *              - adcREG2: ADC2 module pointer\r
 162 *   @param[in] group Hardware group of ADC module:\r
 163 *              - adcGROUP0: ADC event group\r
 164 *              - adcGROUP1: ADC group 1\r
 165 *              - adcGROUP2: ADC group 2\r
 166 *\r
 167 *   This function starts a convesion of the ADC hardware group.\r
 168 *\r
 169 */\r
 170 \r
 171 /** - s_adcSelect is used as constant table for channel selection */\r
 172 static const uint32_t s_adcSelect[2U][3U] =\r
 173 {\r
 174     0x00000000U |\r
 175     0x00000000U |\r
 176     0x00000000U |\r
 177     0x00000000U |\r
 178     0x00000000U |\r
 179     0x00000000U |\r
 180     0x00000000U |\r
 181     0x00000000U |\r
 182     0x00000000U |\r
 183     0x00000000U |\r
 184     0x00000000U |\r
 185     0x00000000U |\r
 186     0x00000000U |\r
 187     0x00000000U |\r
 188     0x00000000U |\r
 189     0x00000000U |\r
 190     0x00000000U |\r
 191     0x00000000U |\r
 192     0x00000000U |\r
 193     0x00000000U |\r
 194     0x00000000U |\r
 195     0x00000000U |\r
 196     0x00000000U |\r
 197     0x00000000U,\r
 198     0x00000001U |\r
 199     0x00000002U |\r
 200     0x00000004U |\r
 201     0x00000008U |\r
 202     0x00000010U |\r
 203     0x00000020U |\r
 204     0x00000040U |\r
 205     0x00000080U |\r
 206     0x00000100U |\r
 207     0x00000200U |\r
 208     0x00000400U |\r
 209     0x00000800U |\r
 210     0x00000000U |\r
 211     0x00000000U |\r
 212     0x00000000U |\r
 213     0x00000000U |\r
 214     0x00000000U |\r
 215     0x00000000U |\r
 216     0x00000000U |\r
 217     0x00000000U |\r
 218     0x00000000U |\r
 219     0x00000000U |\r
 220     0x00000000U |\r
 221     0x00000000U,\r
 222     0x00000000U |\r
 223     0x00000000U |\r
 224     0x00000000U |\r
 225     0x00000000U |\r
 226     0x00000000U |\r
 227     0x00000000U |\r
 228     0x00000000U |\r
 229     0x00000000U |\r
 230     0x00000000U |\r
 231     0x00000000U |\r
 232     0x00000000U |\r
 233     0x00000000U |\r
 234     0x00000000U |\r
 235     0x00000000U |\r
 236     0x00000000U |\r
 237     0x00000000U |\r
 238     0x00000000U |\r
 239     0x00000000U |\r
 240     0x00000000U |\r
 241     0x00000000U |\r
 242     0x00000000U |\r
 243     0x00000000U |\r
 244     0x00000000U |\r
 245     0x00000000U,\r
 246     0x00000000U |\r
 247     0x00000000U |\r
 248     0x00000000U |\r
 249     0x00000000U |\r
 250     0x00000000U |\r
 251     0x00000000U |\r
 252     0x00000000U |\r
 253     0x00000000U |\r
 254     0x00000000U |\r
 255     0x00000000U |\r
 256     0x00000000U |\r
 257     0x00000000U |\r
 258     0x00000000U |\r
 259     0x00000000U |\r
 260     0x00000000U |\r
 261     0x00000000U ,\r
 262     0x00000000U |\r
 263     0x00000000U |\r
 264     0x00000000U |\r
 265     0x00000000U |\r
 266     0x00000000U |\r
 267     0x00000000U |\r
 268     0x00000000U |\r
 269     0x00000000U |\r
 270     0x00000000U |\r
 271     0x00000000U |\r
 272     0x00000000U |\r
 273     0x00000000U |\r
 274     0x00000000U |\r
 275     0x00000000U |\r
 276     0x00000000U |\r
 277     0x00000000U,\r
 278     0x00000000U |\r
 279     0x00000000U |\r
 280     0x00000000U |\r
 281     0x00000000U |\r
 282     0x00000000U |\r
 283     0x00000000U |\r
 284     0x00000000U |\r
 285     0x00000000U |\r
 286     0x00000000U |\r
 287     0x00000000U |\r
 288     0x00000000U |\r
 289     0x00000000U |\r
 290     0x00000000U |\r
 291     0x00000000U |\r
 292     0x00000000U |\r
 293     0x00000000U,\r
 294 };\r
 295 \r
 296 /** - s_adcSelect is used as constant table for channel selection */\r
 297 static const uint32_t s_adcFiFoSize[2U][3U] =\r
 298 {\r
 299     16U,\r
 300     16U,\r
 301     16U,\r
 302     16U,\r
 303     16U,\r
 304     16U,\r
 305 };\r
 306 \r
 307 /* USER CODE BEGIN (6) */\r
 308 /* USER CODE END */\r
 309 \r
 310 void adcStartConversion(adcBASE_t *adc, uint32_t group)\r
 311 {\r
 312     uint32_t index = adc == adcREG1 ? 0U : 1U;\r
 313 \r
 314 /* USER CODE BEGIN (7) */\r
 315 /* USER CODE END */\r
 316 \r
 317     /** - Setup FiFo size */\r
 318     adc->GxINTCR[group] = s_adcFiFoSize[index][group];\r
 319 \r
 320     /** - Start Conversion */\r
 321     adc->GxSEL[group] = s_adcSelect[index][group];\r
 322 \r
 323     /**   @note The function adcInit has to be called before this function can be used. */\r
 324 \r
 325 /* USER CODE BEGIN (8) */\r
 326 /* USER CODE END */\r
 327 }\r
 328 \r
 329 /* USER CODE BEGIN (9) */\r
 330 /* USER CODE END */\r
 331 \r
 332 \r
 333 /** @fn void adcStopConversion(adcBASE_t *adc, uint32_t group)\r
 334 *   @brief Stops an ADC conversion\r
 335 *   @param[in] adc Pointer to ADC module:\r
 336 *              - adcREG1: ADC1 module pointer\r
 337 *              - adcREG2: ADC2 module pointer\r
 338 *   @param[in] group Hardware group of ADC module:\r
 339 *              - adcGROUP0: ADC event group\r
 340 *              - adcGROUP1: ADC group 1\r
 341 *              - adcGROUP2: ADC group 2\r
 342 *\r
 343 *   This function stops a convesion of the ADC hardware group.\r
 344 *\r
 345 */\r
 346 \r
 347 /* USER CODE BEGIN (10) */\r
 348 /* USER CODE END */\r
 349 \r
 350 void adcStopConversion(adcBASE_t *adc, uint32_t group)\r
 351 {\r
 352 /* USER CODE BEGIN (11) */\r
 353 /* USER CODE END */\r
 354 \r
 355     /** - Stop Conversion */\r
 356     adc->GxSEL[group] = 0U;\r
 357 \r
 358     /**   @note The function adcInit has to be called before this function can be used. */\r
 359 \r
 360 /* USER CODE BEGIN (12) */\r
 361 /* USER CODE END */\r
 362 }\r
 363 \r
 364 /* USER CODE BEGIN (13) */\r
 365 /* USER CODE END */\r
 366 \r
 367 \r
 368 /** @fn void adcResetFiFo(adcBASE_t *adc, uint32_t group)\r
 369 *   @brief Resets FiFo read and write pointer.\r
 370 *   @param[in] adc Pointer to ADC module:\r
 371 *              - adcREG1: ADC1 module pointer\r
 372 *              - adcREG2: ADC2 module pointer\r
 373 *   @param[in] group Hardware group of ADC module:\r
 374 *              - adcGROUP0: ADC event group\r
 375 *              - adcGROUP1: ADC group 1\r
 376 *              - adcGROUP2: ADC group 2\r
 377 *\r
 378 *   This function resets the FiFo read and write pointrs.\r
 379 *\r
 380 */\r
 381 \r
 382 /* USER CODE BEGIN (14) */\r
 383 /* USER CODE END */\r
 384 \r
 385 void adcResetFiFo(adcBASE_t *adc, uint32_t group)\r
 386 {\r
 387 /* USER CODE BEGIN (15) */\r
 388 /* USER CODE END */\r
 389 \r
 390     /** - Reset FiFo */\r
 391     adc->GxFIFORESETCR[group] = 1U;\r
 392 \r
 393     /**   @note The function adcInit has to be called before this function can be used.\n\r
 394     *           the conversion should be stopped before calling this function. \r
 395     */\r
 396 \r
 397 /* USER CODE BEGIN (16) */\r
 398 /* USER CODE END */\r
 399 }\r
 400 \r
 401 /* USER CODE BEGIN (17) */\r
 402 /* USER CODE END */\r
 403 \r
 404 \r
 405 /** @fn uint32_t adcGetData(adcBASE_t *adc, uint32_t group, adcData_t *data)\r
 406 *   @brief Gets converted a ADC values\r
 407 *   @param[in] adc Pointer to ADC module:\r
 408 *              - adcREG1: ADC1 module pointer\r
 409 *              - adcREG2: ADC2 module pointer\r
 410 *              - adcREG3: ADC3 module pointer\r
 411 *   @param[in] group Hardware group of ADC module:\r
 412 *              - adcGROUP0: ADC event group\r
 413 *              - adcGROUP1: ADC group 1\r
 414 *              - adcGROUP2: ADC group 2\r
 415 *   @param[out] data Pointer to store ADC converted data\r
 416 *   @return The function will return the number of converted values copied into data buffer:\r
 417 *\r
 418 *   This function writes a ADC message into a ADC message box.\r
 419 *\r
 420 */\r
 421 \r
 422 \r
 423 /* USER CODE BEGIN (18) */\r
 424 /* USER CODE END */\r
 425 \r
 426 uint32_t adcGetData(adcBASE_t *adc, uint32_t group, adcData_t *data)\r
 427 {\r
 428     uint32_t       i;\r
 429     uint32_t  buf;\r
 430     uint32_t  mode;    \r
 431     uint32_t  index = adc == adcREG1 ? 0U : 1U;\r
 432     uint32_t       count = adc->GxINTCR[group] >= 256U ? s_adcFiFoSize[index][group] : s_adcFiFoSize[index][group] - (uint32_t)(adc->GxINTCR[group] & 0xFF);\r
 433     adcData_t *ptr = data; \r
 434 \r
 435 /* USER CODE BEGIN (19) */\r
 436 /* USER CODE END */\r
 437 \r
 438     mode = ((adc->GxMODECR[group]) & 0x00000300U);\r
 439 \r
 440     if(mode == ADC_12_BIT)\r
 441       {\r
 442         /** -  Get conversion data and channel/pin id */\r
 443         for (i = 0; i < count; i++)\r
 444         {\r
 445           buf        = adc->GxBUF[group].BUF0;\r
 446           ptr->value = (uint16_t)(buf & 0xFFFU);\r
 447           ptr->id    = (uint32_t)((buf >> 16U) & 0x1FU);\r
 448           ptr++;\r
 449         }\r
 450       }\r
 451       else\r
 452       {\r
 453         /** -  Get conversion data and channel/pin id */\r
 454         for (i = 0; i < count; i++)\r
 455         {\r
 456           buf        = adc->GxBUF[group].BUF0;\r
 457           ptr->value = (uint16_t)(buf & 0x3FFU);\r
 458           ptr->id    = (uint32_t)((buf >> 10U) & 0x1FU);\r
 459           ptr++;\r
 460         }\r
 461       }\r
 462 \r
 463 \r
 464     adc->GxINTFLG[group] = 9U;\r
 465 \r
 466     /**   @note The function adcInit has to be called before this function can be used.\n\r
 467     *           The user is responsible to initialize the message box.\r
 468     */\r
 469 \r
 470 /* USER CODE BEGIN (20) */\r
 471 /* USER CODE END */\r
 472 \r
 473     return count;\r
 474 }\r
 475 \r
 476 /* USER CODE BEGIN (21) */\r
 477 /* USER CODE END */\r
 478 \r
 479 \r
 480 /** @fn uint32_t adcIsFifoFull(adcBASE_t *adc, uint32_t group)\r
 481 *   @brief Checks if FiFo buffer is full\r
 482 *   @param[in] adc Pointer to ADC module:\r
 483 *              - adcREG1: ADC1 module pointer\r
 484 *              - adcREG2: ADC2 module pointer\r
 485 *              - adcREG3: ADC3 module pointer\r
 486 *   @param[in] group Hardware group of ADC module:\r
 487 *              - adcGROUP0: ADC event group\r
 488 *              - adcGROUP1: ADC group 1\r
 489 *              - adcGROUP2: ADC group 2\r
 490 *   @return The function will return:\r
 491 *           - 0: When FiFo buffer is not full   \r
 492 *           - 1: When FiFo buffer is full   \r
 493 *           - 3: When FiFo buffer overflow occured    \r
 494 *\r
 495 *   This function checks FiFo buffer status.\r
 496 *\r
 497 */\r
 498 \r
 499 \r
 500 /* USER CODE BEGIN (22) */\r
 501 /* USER CODE END */\r
 502 \r
 503 uint32_t adcIsFifoFull(adcBASE_t *adc, uint32_t group)\r
 504 {\r
 505     uint32_t flags;\r
 506 \r
 507 /* USER CODE BEGIN (23) */\r
 508 /* USER CODE END */\r
 509 \r
 510     /** - Read FiFo flags */\r
 511     flags = adc->GxINTFLG[group] & 3U;\r
 512 \r
 513     /**   @note The function adcInit has to be called before this function can be used. */\r
 514 \r
 515 /* USER CODE BEGIN (24) */\r
 516 /* USER CODE END */\r
 517 \r
 518     return flags;\r
 519 }\r
 520 \r
 521 /* USER CODE BEGIN (25) */\r
 522 /* USER CODE END */\r
 523 \r
 524 \r
 525 /** @fn uint32_t adcIsConversionComplete(adcBASE_t *adc, uint32_t group)\r
 526 *   @brief Checks if Conversion is complete\r
 527 *   @param[in] adc Pointer to ADC module:\r
 528 *              - adcREG1: ADC1 module pointer\r
 529 *              - adcREG2: ADC2 module pointer\r
 530 *              - adcREG3: ADC3 module pointer\r
 531 *   @param[in] group Hardware group of ADC module:\r
 532 *              - adcGROUP0: ADC event group\r
 533 *              - adcGROUP1: ADC group 1\r
 534 *              - adcGROUP2: ADC group 2\r
 535 *   @return The function will return:\r
 536 *           - 0: When is not finished   \r
 537 *           - 8: When conversion is complete   \r
 538 *\r
 539 *   This function checks if conversion is complete.\r
 540 *\r
 541 */\r
 542 \r
 543 \r
 544 /* USER CODE BEGIN (26) */\r
 545 /* USER CODE END */\r
 546 \r
 547 uint32_t adcIsConversionComplete(adcBASE_t *adc, uint32_t group)\r
 548 {\r
 549     uint32_t flags;\r
 550 \r
 551 /* USER CODE BEGIN (27) */\r
 552 /* USER CODE END */\r
 553 \r
 554     /** - Read conversion flags */\r
 555     flags = adc->GxINTFLG[group] & 8U;\r
 556 \r
 557     /**   @note The function adcInit has to be called before this function can be used. */\r
 558 \r
 559 /* USER CODE BEGIN (28) */\r
 560 /* USER CODE END */\r
 561 \r
 562     return flags;\r
 563 }\r
 564 \r
 565 /* USER CODE BEGIN (29) */\r
 566 /* USER CODE END */\r
 567 \r
 568 /** @fn void adcCalibration(adcBASE_t *adc)\r
 569 *   @brief Computes offset error using Calibration mode\r
 570 *   @param[in] adc Pointer to ADC module:\r
 571 *              - adcREG1: ADC1 module pointer\r
 572 *              - adcREG2: ADC2 module pointer\r
 573 *              - adcREG3: ADC3 module pointer\r
 574 *   This function computes offset error using Calibration mode\r
 575 *\r
 576 */\r
 577 void adcCalibration(adcBASE_t *adc)\r
 578 {\r
 579 /* USER CODE BEGIN (30) */\r
 580 /* USER CODE END */\r
 581     \r
 582         uint32_t conv_val[5]={0,0,0,0,0},loop_index=0;\r
 583         uint32_t offset_error=0;\r
 584         uint32_t backup_mode;\r
 585         \r
 586         /** - Backup Mode before Calibration  */\r
 587         backup_mode = adc->OPMODECR;\r
 588         \r
 589         /** - Enable 12-BIT ADC  */\r
 590         adcREG1->OPMODECR |= 0x80000000U;\r
 591 \r
 592         /* Disable all channels for conversion */\r
 593         adc->GxSEL[0]=0x00;\r
 594         adc->GxSEL[1]=0x00;\r
 595         adc->GxSEL[2]=0x00;\r
 596 \r
 597         for(loop_index=0;loop_index<4;loop_index++)\r
 598         {\r
 599                 /* Disable Self Test and Calibration mode */\r
 600                 adc->CALCR=0x0;\r
 601         \r
 602                 switch(loop_index)\r
 603                 {\r
 604                         case 0 :        /* Test 1 : Bride En = 0 , HiLo =0 */\r
 605                                                 adc->CALCR=0x0;\r
 606                                                 break;\r
 607 \r
 608                         case 1 :        /* Test 1 : Bride En = 0 , HiLo =1 */\r
 609                                                 adc->CALCR=0x0100;\r
 610                                                 break;\r
 611 \r
 612                         case 2 :        /* Test 1 : Bride En = 1 , HiLo =0 */\r
 613                                                 adc->CALCR=0x0200;\r
 614                                                 break;\r
 615                 \r
 616                         case 3 :        /* Test 1 : Bride En = 1 , HiLo =1 */\r
 617                                                 adc->CALCR=0x0300;\r
 618                                                 break;\r
 619                 }\r
 620         \r
 621                 /* Enable Calibration mode */\r
 622                 adc->CALCR|=0x1;\r
 623         \r
 624                 /* Start calibration conversion */\r
 625                 adc->CALCR|=0x00010000;\r
 626 \r
 627                 /* Wait for calibration conversion to complete */\r
 628                 while((adc->CALCR & 0x00010000)==0x00010000);\r
 629 \r
 630                 /* Read converted value */\r
 631                 conv_val[loop_index]= adc->CALR;\r
 632         }\r
 633 \r
 634         /* Disable Self Test and Calibration mode */\r
 635         adc->CALCR=0x0;\r
 636 \r
 637         /* Compute the Offset error correction value */\r
 638         conv_val[4]=conv_val[0]+ conv_val[1] + conv_val[2] + conv_val[3];\r
 639 \r
 640         conv_val[4]=(conv_val[4]/4);\r
 641 \r
 642         offset_error=conv_val[4]-0x7FF;\r
 643 \r
 644         /*Write the offset error to the Calibration register */\r
 645         /* Load 2;s complement of the computed value to ADCALR register */\r
 646         offset_error=~offset_error;\r
 647         offset_error=offset_error & 0xFFF;\r
 648         offset_error=offset_error+1;\r
 649 \r
 650         adc->CALR = offset_error;\r
 651 \r
 652   /** - Restore Mode after Calibration  */\r
 653         adc->OPMODECR = backup_mode;\r
 654         \r
 655  /**   @note The function adcInit has to be called before using this function. */\r
 656 \r
 657 /* USER CODE BEGIN (31) */\r
 658 /* USER CODE END */\r
 659 }\r
 660 \r
 661 \r
 662 /** @fn void adcMidPointCalibration(adcBASE_t *adc)\r
 663 *   @brief Computes offset error using Mid Point Calibration mode\r
 664 *   @param[in] adc Pointer to ADC module:\r
 665 *              - adcREG1: ADC1 module pointer\r
 666 *              - adcREG2: ADC2 module pointer\r
 667 *              - adcREG3: ADC3 module pointer\r
 668 *   This function computes offset error using Mid Point Calibration mode\r
 669 *\r
 670 */\r
 671 \r
 672 /* USER CODE BEGIN (32) */\r
 673 /* USER CODE END */\r
 674 \r
 675 uint32_t adcMidPointCalibration(adcBASE_t *adc)\r
 676 {\r
 677 /* USER CODE BEGIN (33) */\r
 678 /* USER CODE END */\r
 679     \r
 680         uint32_t conv_val[3]={0,0,0},loop_index=0;\r
 681         uint32_t offset_error=0;\r
 682         uint32_t backup_mode;\r
 683         \r
 684         /** - Backup Mode before Calibration  */\r
 685         backup_mode = adc->OPMODECR;\r
 686         \r
 687         /** - Enable 12-BIT ADC  */\r
 688         adcREG1->OPMODECR |= 0x80000000U;\r
 689 \r
 690         /* Disable all channels for conversion */\r
 691         adc->GxSEL[0]=0x00;\r
 692         adc->GxSEL[1]=0x00;\r
 693         adc->GxSEL[2]=0x00;\r
 694 \r
 695         for(loop_index=0;loop_index<2;loop_index++)\r
 696         {\r
 697                 /* Disable Self Test and Calibration mode */\r
 698                 adc->CALCR=0x0;\r
 699         \r
 700                 switch(loop_index)\r
 701                 {\r
 702                         case 0 :        /* Test 1 : Bride En = 0 , HiLo =0 */\r
 703                                                 adc->CALCR=0x0;\r
 704                                                 break;\r
 705 \r
 706                         case 1 :        /* Test 1 : Bride En = 0 , HiLo =1 */\r
 707                                                 adc->CALCR=0x0100;\r
 708                                                 break;\r
 709 \r
 710                 }\r
 711         \r
 712                 /* Enable Calibration mode */\r
 713                 adc->CALCR|=0x1;\r
 714         \r
 715                 /* Start calibration conversion */\r
 716                 adc->CALCR|=0x00010000;\r
 717 \r
 718                 /* Wait for calibration conversion to complete */\r
 719                 while((adc->CALCR & 0x00010000)==0x00010000);\r
 720 \r
 721                 /* Read converted value */\r
 722                 conv_val[loop_index]= adc->CALR;\r
 723         }\r
 724 \r
 725         /* Disable Self Test and Calibration mode */\r
 726         adc->CALCR=0x0;\r
 727 \r
 728         /* Compute the Offset error correction value */\r
 729         conv_val[2]=(conv_val[0])+ (conv_val[1]);\r
 730 \r
 731         conv_val[2]=(conv_val[2]/2);\r
 732 \r
 733         offset_error=conv_val[2]-0x7FF;\r
 734 \r
 735         /* Write the offset error to the Calibration register           */\r
 736         /* Load 2's complement of the computed value to ADCALR register */\r
 737         offset_error=~offset_error;\r
 738         offset_error=offset_error & 0xFFF;\r
 739         offset_error=offset_error+1;\r
 740 \r
 741         adc->CALR = offset_error;\r
 742 \r
 743   /** - Restore Mode after Calibration  */\r
 744         adc->OPMODECR = backup_mode;\r
 745         \r
 746         return(offset_error);\r
 747 \r
 748  /**   @note The function adcInit has to be called before this function can be used. */\r
 749 \r
 750 /* USER CODE BEGIN (34) */\r
 751 /* USER CODE END */\r
 752 }\r
 753 \r
 754 /* USER CODE BEGIN (35) */\r
 755 /* USER CODE END */\r
 756 \r
 757 /** @fn void adcEnableNotification(adcBASE_t *adc, uint32_t group)\r
 758 *   @brief Enable notification\r
 759 *   @param[in] adc Pointer to ADC module:\r
 760 *              - adcREG1: ADC1 module pointer\r
 761 *              - adcREG2: ADC2 module pointer\r
 762 *              - adcREG3: ADC3 module pointer\r
 763 *   @param[in] group Hardware group of ADC module:\r
 764 *              - adcGROUP0: ADC event group\r
 765 *              - adcGROUP1: ADC group 1\r
 766 *              - adcGROUP2: ADC group 2\r
 767 *\r
 768 *   This function will enable the notification of a conversion.\r
 769 *   In single conversion mode for conversion complete and\r
 770 *   in continuous conversion mode when the FiFo buffer is full.\r
 771 *\r
 772 */\r
 773 \r
 774 /* USER CODE BEGIN (36) */\r
 775 /* USER CODE END */\r
 776 \r
 777 void adcEnableNotification(adcBASE_t *adc, uint32_t group)\r
 778 {\r
 779     uint32_t notif = adc->GxMODECR[group] & 2U ? 1U : 8U;\r
 780 \r
 781 /* USER CODE BEGIN (37) */\r
 782 /* USER CODE END */\r
 783 \r
 784     adc->GxINTENA[group] = notif;\r
 785 \r
 786     /**   @note The function adcInit has to be called before this function can be used.\n\r
 787     *           This function should be called before the conversion is started\r
 788     */\r
 789 \r
 790 /* USER CODE BEGIN (38) */\r
 791 /* USER CODE END */\r
 792 }\r
 793 \r
 794 /* USER CODE BEGIN (39) */\r
 795 /* USER CODE END */\r
 796 \r
 797 \r
 798 /** @fn void adcDisableNotification(adcBASE_t *adc, uint32_t group)\r
 799 *   @brief Disable notification\r
 800 *   @param[in] adc Pointer to ADC module:\r
 801 *              - adcREG1: ADC1 module pointer\r
 802 *              - adcREG2: ADC2 module pointer\r
 803 *              - adcREG3: ADC3 module pointer\r
 804 *   @param[in] group Hardware group of ADC module:\r
 805 *              - adcGROUP0: ADC event group\r
 806 *              - adcGROUP1: ADC group 1\r
 807 *              - adcGROUP2: ADC group 2\r
 808 *\r
 809 *   This function will disable the notification of a conversion.\r
 810 */\r
 811 \r
 812 /* USER CODE BEGIN (40) */\r
 813 /* USER CODE END */\r
 814 \r
 815 void adcDisableNotification(adcBASE_t *adc, uint32_t group)\r
 816 {\r
 817 /* USER CODE BEGIN (41) */\r
 818 /* USER CODE END */\r
 819 \r
 820     adc->GxINTENA[group] = 0U;\r
 821 \r
 822     /**   @note The function adcInit has to be called before this function can be used. */\r
 823 \r
 824 /* USER CODE BEGIN (42) */\r
 825 /* USER CODE END */\r
 826 }\r
 827 \r
 828 /* USER CODE BEGIN (43) */\r
 829 /* USER CODE END */\r
 830 \r
 831 \r
 832 /** @fn void adc1Group0Interrupt(void)\r
 833 *   @brief ADC1 Event Group Interrupt Handler\r
 834 */\r
 835 \r
 836 /* USER CODE BEGIN (44) */\r
 837 /* USER CODE END */\r
 838 \r
 839 #pragma INTERRUPT(adc1Group0Interrupt, IRQ)\r
 840 \r
 841 void adc1Group0Interrupt(void)\r
 842 {\r
 843 /* USER CODE BEGIN (45) */\r
 844 /* USER CODE END */\r
 845     \r
 846     adcREG1->GxINTFLG[0U] = 9U;\r
 847 \r
 848     adcNotification(adcREG1, adcGROUP0);\r
 849 \r
 850 /* USER CODE BEGIN (46) */\r
 851 /* USER CODE END */\r
 852 }\r
 853 \r
 854 /* USER CODE BEGIN (47) */\r
 855 /* USER CODE END */\r
 856 \r
 857 \r
 858 /** @fn void adc1Group1Interrupt(void)\r
 859 *   @brief ADC1 Group 1 Interrupt Handler\r
 860 */\r
 861 \r
 862 /* USER CODE BEGIN (48) */\r
 863 /* USER CODE END */\r
 864 \r
 865 #pragma INTERRUPT(adc1Group1Interrupt, IRQ)\r
 866 \r
 867 void adc1Group1Interrupt(void)\r
 868 {\r
 869 /* USER CODE BEGIN (49) */\r
 870     adcNotification(adcREG1, adcGROUP1);\r
 871 /* USER CODE END */\r
 872 \r
 873 /* USER CODE BEGIN (50) */\r
 874 /* USER CODE END */\r
 875 }\r
 876 \r
 877 /* USER CODE BEGIN (51) */\r
 878 /* USER CODE END */\r
 879 \r
 880 \r
 881 /** @fn void adc1Group2Interrupt(void)\r
 882 *   @brief ADC1 Group 2 Interrupt Handler\r
 883 */\r
 884 \r
 885 /* USER CODE BEGIN (52) */\r
 886 /* USER CODE END */\r
 887 \r
 888 #pragma INTERRUPT(adc1Group2Interrupt, IRQ)\r
 889 \r
 890 void adc1Group2Interrupt(void)\r
 891 {\r
 892 /* USER CODE BEGIN (53) */\r
 893 /* USER CODE END */\r
 894     \r
 895     adcREG1->GxINTFLG[2U] = 9U;\r
 896 \r
 897     adcNotification(adcREG1, adcGROUP2);\r
 898 \r
 899 /* USER CODE BEGIN (54) */\r
 900 /* USER CODE END */\r
 901 }\r
 902 \r
 903 /* USER CODE BEGIN (55) */\r
 904 /* USER CODE END */\r
 905 \r
 906 \r
 907 /** @fn void adc2Group0Interrupt(void)\r
 908 *   @brief ADC2 Event Group Interrupt Handler\r
 909 */\r
 910 \r
 911 /* USER CODE BEGIN (56) */\r
 912 /* USER CODE END */\r
 913 \r
 914 #pragma INTERRUPT(adc2Group0Interrupt, IRQ)\r
 915 \r
 916 void adc2Group0Interrupt(void)\r
 917 {\r
 918 /* USER CODE BEGIN (57) */\r
 919 /* USER CODE END */\r
 920     \r
 921     adcREG2->GxINTFLG[0U] = 9U;\r
 922 \r
 923     adcNotification(adcREG2, adcGROUP0);\r
 924 \r
 925 /* USER CODE BEGIN (58) */\r
 926 /* USER CODE END */\r
 927 }\r
 928 \r
 929 /* USER CODE BEGIN (59) */\r
 930 /* USER CODE END */\r
 931 \r
 932 \r
 933 /** @fn void adc2Group1Interrupt(void)\r
 934 *   @brief ADC2 Group 1 Interrupt Handler\r
 935 */\r
 936 \r
 937 /* USER CODE BEGIN (60) */\r
 938 /* USER CODE END */\r
 939 \r
 940 #pragma INTERRUPT(adc2Group1Interrupt, IRQ)\r
 941 \r
 942 void adc2Group1Interrupt(void)\r
 943 {\r
 944 /* USER CODE BEGIN (61) */\r
 945 /* USER CODE END */\r
 946     \r
 947     adcREG2->GxINTFLG[1U] = 9U;\r
 948 \r
 949     adcNotification(adcREG2, adcGROUP1);\r
 950 \r
 951 /* USER CODE BEGIN (62) */\r
 952 /* USER CODE END */\r
 953 }\r
 954 \r
 955 /* USER CODE BEGIN (63) */\r
 956 /* USER CODE END */\r
 957 \r
 958 \r
 959 /** @fn void adc2Group2Interrupt(void)\r
 960 *   @brief ADC2 Group 2 Interrupt Handler\r
 961 */\r
 962 \r
 963 /* USER CODE BEGIN (64) */\r
 964 /* USER CODE END */\r
 965 \r
 966 #pragma INTERRUPT(adc2Group2Interrupt, IRQ)\r
 967 \r
 968 void adc2Group2Interrupt(void)\r
 969 {\r
 970 /* USER CODE BEGIN (65) */\r
 971 /* USER CODE END */\r
 972     \r
 973     adcREG2->GxINTFLG[2U] = 9U;\r
 974 \r
 975     adcNotification(adcREG2, adcGROUP2);\r
 976 \r
 977 /* USER CODE BEGIN (66) */\r
 978 /* USER CODE END */\r
 979 }\r
 980 \r
 981 /* USER CODE BEGIN (67) */\r
 982 /* USER CODE END */\r
 983 \r
 984 \r