git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_LM3S811_IAR/LuminaryCode/qei.c

   1 //*****************************************************************************\r
   2 //\r
   3 // qei.c - Driver for the Quadrature Encoder with Index.\r
   4 //\r
   5 // Copyright (c) 2005,2006 Luminary Micro, Inc.  All rights reserved.\r
   6 //\r
   7 // Software License Agreement\r
   8 //\r
   9 // Luminary Micro, Inc. (LMI) is supplying this software for use solely and\r
  10 // exclusively on LMI's Stellaris Family of microcontroller products.\r
  11 //\r
  12 // The software is owned by LMI and/or its suppliers, and is protected under\r
  13 // applicable copyright laws.  All rights are reserved.  Any use in violation\r
  14 // of the foregoing restrictions may subject the user to criminal sanctions\r
  15 // under applicable laws, as well as to civil liability for the breach of the\r
  16 // terms and conditions of this license.\r
  17 //\r
  18 // THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED\r
  19 // OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF\r
  20 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.\r
  21 // LMI SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR\r
  22 // CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.\r
  23 //\r
  24 // This is part of revision 991 of the Stellaris Driver Library.\r
  25 //\r
  26 //*****************************************************************************\r
  27 \r
  28 //*****************************************************************************\r
  29 //\r
  30 //! \addtogroup qei_api\r
  31 //! @{\r
  32 //\r
  33 //*****************************************************************************\r
  34 \r
  35 #include "../hw_ints.h"\r
  36 #include "../hw_memmap.h"\r
  37 #include "../hw_qei.h"\r
  38 #include "../hw_types.h"\r
  39 #include "debug.h"\r
  40 #include "interrupt.h"\r
  41 #include "qei.h"\r
  42 \r
  43 //*****************************************************************************\r
  44 //\r
  45 //! Enables the quadrature encoder.\r
  46 //!\r
  47 //! \param ulBase is the base address of the quadrature encoder module.\r
  48 //!\r
  49 //! This will enable operation of the quadrature encoder module.  It must be\r
  50 //! configured before it is enabled.\r
  51 //!\r
  52 //! \sa QEIConfigure()\r
  53 //!\r
  54 //! \return None.\r
  55 //\r
  56 //*****************************************************************************\r
  57 #if defined(GROUP_enable) || defined(BUILD_ALL) || defined(DOXYGEN)\r
  58 void\r
  59 QEIEnable(unsigned long ulBase)\r
  60 {\r
  61     //\r
  62     // Check the arguments.\r
  63     //\r
  64     ASSERT(ulBase == QEI_BASE);\r
  65 \r
  66     //\r
  67     // Enable the QEI module.\r
  68     //\r
  69     HWREG(ulBase + QEI_O_CTL) |= QEI_CTL_ENABLE;\r
  70 }\r
  71 #endif\r
  72 \r
  73 //*****************************************************************************\r
  74 //\r
  75 //! Disables the quadrature encoder.\r
  76 //!\r
  77 //! \param ulBase is the base address of the quadrature encoder module.\r
  78 //!\r
  79 //! This will disable operation of the quadrature encoder module.\r
  80 //!\r
  81 //! \return None.\r
  82 //\r
  83 //*****************************************************************************\r
  84 #if defined(GROUP_disable) || defined(BUILD_ALL) || defined(DOXYGEN)\r
  85 void\r
  86 QEIDisable(unsigned long ulBase)\r
  87 {\r
  88     //\r
  89     // Check the arguments.\r
  90     //\r
  91     ASSERT(ulBase == QEI_BASE);\r
  92 \r
  93     //\r
  94     // Disable the QEI module.\r
  95     //\r
  96     HWREG(ulBase + QEI_O_CTL) &= ~(QEI_CTL_ENABLE);\r
  97 }\r
  98 #endif\r
  99 \r
 100 //*****************************************************************************\r
 101 //\r
 102 //! Configures the quadrature encoder.\r
 103 //!\r
 104 //! \param ulBase is the base address of the quadrature encoder module.\r
 105 //! \param ulConfig is the configuration for the quadrature encoder.  See below\r
 106 //! for a description of this parameter.\r
 107 //! \param ulMaxPosition specifies the maximum position value.\r
 108 //!\r
 109 //! This will configure the operation of the quadrature encoder.  The\r
 110 //! \e ulConfig parameter provides the configuration of the encoder and is the\r
 111 //! logical OR of several values:\r
 112 //!\r
 113 //! - \b QEI_CONFIG_CAPTURE_A or \b QEI_CONFIG_CAPTURE_A_B to specify if edges\r
 114 //!   on channel A or on both channels A and B should be counted by the\r
 115 //!   position integrator and velocity accumulator.\r
 116 //! - \b QEI_CONFIG_NO_RESET or \b QEI_CONFIG_RESET_IDX to specify if the\r
 117 //!   position integrator should be reset when the index pulse is detected.\r
 118 //! - \b QEI_CONFIG_QUADRATURE or \b QEI_CONFIG_CLOCK_DIR to specify if\r
 119 //!   quadrature signals are being provided on ChA and ChB, or if a direction\r
 120 //!   signal and a clock are being provided instead.\r
 121 //! - \b QEI_CONFIG_NO_SWAP or \b QEI_CONFIG_SWAP to specify if the signals\r
 122 //!   provided on ChA and ChB should be swapped before being processed.\r
 123 //!\r
 124 //! \e ulMaxPosition is the maximum value of the position integrator, and is\r
 125 //! the value used to reset the position capture when in index reset mode and\r
 126 //! moving in the reverse (negative) direction.\r
 127 //!\r
 128 //! \return None.\r
 129 //\r
 130 //*****************************************************************************\r
 131 #if defined(GROUP_configure) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 132 void\r
 133 QEIConfigure(unsigned long ulBase, unsigned long ulConfig,\r
 134              unsigned long ulMaxPosition)\r
 135 {\r
 136     //\r
 137     // Check the arguments.\r
 138     //\r
 139     ASSERT(ulBase == QEI_BASE);\r
 140 \r
 141     //\r
 142     // Write the new configuration to the hardware.\r
 143     //\r
 144     HWREG(ulBase + QEI_O_CTL) = ((HWREG(ulBase + QEI_O_CTL) &\r
 145                                   ~(QEI_CTL_CAPMODE | QEI_CTL_RESMODE |\r
 146                                     QEI_CTL_SIGMODE | QEI_CTL_SWAP)) |\r
 147                                  ulConfig);\r
 148 \r
 149     //\r
 150     // Set the maximum position.\r
 151     //\r
 152     HWREG(ulBase + QEI_O_MAXPOS) = ulMaxPosition;\r
 153 }\r
 154 #endif\r
 155 \r
 156 //*****************************************************************************\r
 157 //\r
 158 //! Gets the current encoder position.\r
 159 //!\r
 160 //! \param ulBase is the base address of the quadrature encoder module.\r
 161 //!\r
 162 //! This returns the current position of the encoder.  Depending upon the\r
 163 //! configuration of the encoder, and the incident of an index pulse, this\r
 164 //! value may or may not contain the expected data (i.e. if in reset on index\r
 165 //! mode, if an index pulse has not been encountered, the position counter will\r
 166 //! not be aligned with the index pulse yet).\r
 167 //!\r
 168 //! \return The current position of the encoder.\r
 169 //\r
 170 //*****************************************************************************\r
 171 #if defined(GROUP_positionget) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 172 unsigned long\r
 173 QEIPositionGet(unsigned long ulBase)\r
 174 {\r
 175     //\r
 176     // Check the arguments.\r
 177     //\r
 178     ASSERT(ulBase == QEI_BASE);\r
 179 \r
 180     //\r
 181     // Return the current position counter.\r
 182     //\r
 183     return(HWREG(ulBase + QEI_O_POS));\r
 184 }\r
 185 #endif\r
 186 \r
 187 //*****************************************************************************\r
 188 //\r
 189 //! Sets the current encoder position.\r
 190 //!\r
 191 //! \param ulBase is the base address of the quadrature encoder module.\r
 192 //! \param ulPosition is the new position for the encoder.\r
 193 //!\r
 194 //! This sets the current position of the encoder; the encoder position will\r
 195 //! then be measured relative to this value.\r
 196 //!\r
 197 //! \return None.\r
 198 //\r
 199 //*****************************************************************************\r
 200 #if defined(GROUP_positionset) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 201 void\r
 202 QEIPositionSet(unsigned long ulBase, unsigned long ulPosition)\r
 203 {\r
 204     //\r
 205     // Check the arguments.\r
 206     //\r
 207     ASSERT(ulBase == QEI_BASE);\r
 208 \r
 209     //\r
 210     // Set the position counter.\r
 211     //\r
 212     HWREG(ulBase + QEI_O_POS) = ulPosition;\r
 213 }\r
 214 #endif\r
 215 \r
 216 //*****************************************************************************\r
 217 //\r
 218 //! Gets the current direction of rotation.\r
 219 //!\r
 220 //! \param ulBase is the base address of the quadrature encoder module.\r
 221 //!\r
 222 //! This returns the current direction of rotation.  In this case, current\r
 223 //! means the most recently detected direction of the encoder; it may not be\r
 224 //! presently moving but this is the direction it last moved before it stopped.\r
 225 //!\r
 226 //! \return 1 if moving in the forward direction or -1 if moving in the reverse\r
 227 //! direction.\r
 228 //\r
 229 //*****************************************************************************\r
 230 #if defined(GROUP_directionget) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 231 long\r
 232 QEIDirectionGet(unsigned long ulBase)\r
 233 {\r
 234     //\r
 235     // Check the arguments.\r
 236     //\r
 237     ASSERT(ulBase == QEI_BASE);\r
 238 \r
 239     //\r
 240     // Return the direction of rotation.\r
 241     //\r
 242     return((HWREG(ulBase + QEI_O_STAT) & QEI_STAT_DIRECTION) ? -1 : 1);\r
 243 }\r
 244 #endif\r
 245 \r
 246 //*****************************************************************************\r
 247 //\r
 248 //! Gets the encoder error indicator.\r
 249 //!\r
 250 //! \param ulBase is the base address of the quadrature encoder module.\r
 251 //!\r
 252 //! This returns the error indicator for the quadrature encoder.  It is an\r
 253 //! error for both of the signals of the quadrature input to change at the same\r
 254 //! time.\r
 255 //!\r
 256 //! \return true if an error has occurred and false otherwise.\r
 257 //\r
 258 //*****************************************************************************\r
 259 #if defined(GROUP_errorget) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 260 tBoolean\r
 261 QEIErrorGet(unsigned long ulBase)\r
 262 {\r
 263     //\r
 264     // Check the arguments.\r
 265     //\r
 266     ASSERT(ulBase == QEI_BASE);\r
 267 \r
 268     //\r
 269     // Return the error indicator.\r
 270     //\r
 271     return((HWREG(ulBase + QEI_O_STAT) & QEI_STAT_ERROR) ? true : false);\r
 272 }\r
 273 #endif\r
 274 \r
 275 //*****************************************************************************\r
 276 //\r
 277 //! Enables the velocity capture.\r
 278 //!\r
 279 //! \param ulBase is the base address of the quadrature encoder module.\r
 280 //!\r
 281 //! This will enable operation of the velocity capture in the quadrature\r
 282 //! encoder module.  It must be configured before it is enabled.  Velocity\r
 283 //! capture will not occur if the quadrature encoder is not enabled.\r
 284 //!\r
 285 //! \sa QEIVelocityConfigure() and QEIEnable()\r
 286 //!\r
 287 //! \return None.\r
 288 //\r
 289 //*****************************************************************************\r
 290 #if defined(GROUP_velocityenable) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 291 void\r
 292 QEIVelocityEnable(unsigned long ulBase)\r
 293 {\r
 294     //\r
 295     // Check the arguments.\r
 296     //\r
 297     ASSERT(ulBase == QEI_BASE);\r
 298 \r
 299     //\r
 300     // Enable the velocity capture.\r
 301     //\r
 302     HWREG(ulBase + QEI_O_CTL) |= QEI_CTL_VELEN;\r
 303 }\r
 304 #endif\r
 305 \r
 306 //*****************************************************************************\r
 307 //\r
 308 //! Disables the velocity capture.\r
 309 //!\r
 310 //! \param ulBase is the base address of the quadrature encoder module.\r
 311 //!\r
 312 //! This will disable operation of the velocity capture in the quadrature\r
 313 //! encoder module.\r
 314 //!\r
 315 //! \return None.\r
 316 //\r
 317 //*****************************************************************************\r
 318 #if defined(GROUP_velocitydisable) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 319 void\r
 320 QEIVelocityDisable(unsigned long ulBase)\r
 321 {\r
 322     //\r
 323     // Check the arguments.\r
 324     //\r
 325     ASSERT(ulBase == QEI_BASE);\r
 326 \r
 327     //\r
 328     // Disable the velocity capture.\r
 329     //\r
 330     HWREG(ulBase + QEI_O_CTL) &= ~(QEI_CTL_VELEN);\r
 331 }\r
 332 #endif\r
 333 \r
 334 //*****************************************************************************\r
 335 //\r
 336 //! Configures the velocity capture.\r
 337 //!\r
 338 //! \param ulBase is the base address of the quadrature encoder module.\r
 339 //! \param ulPreDiv specifies the predivider applied to the input quadrature\r
 340 //! signal before it is counted; can be one of QEI_VELDIV_1, QEI_VELDIV_2,\r
 341 //! QEI_VELDIV_4, QEI_VELDIV_8, QEI_VELDIV_16, QEI_VELDIV_32, QEI_VELDIV_64, or\r
 342 //! QEI_VELDIV_128.\r
 343 //! \param ulPeriod specifies the number of clock ticks over which to measure\r
 344 //! the velocity; must be non-zero.\r
 345 //!\r
 346 //! This will configure the operation of the velocity capture portion of the\r
 347 //! quadrature encoder.  The position increment signal is predivided as\r
 348 //! specified by \e ulPreDiv before being accumulated by the velocity capture.\r
 349 //! The divided signal is accumulated over \e ulPeriod system clock before\r
 350 //! being saved and resetting the accumulator.\r
 351 //!\r
 352 //! \return None.\r
 353 //\r
 354 //*****************************************************************************\r
 355 #if defined(GROUP_velocityconfigure) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 356 void\r
 357 QEIVelocityConfigure(unsigned long ulBase, unsigned long ulPreDiv,\r
 358                      unsigned long ulPeriod)\r
 359 {\r
 360     //\r
 361     // Check the arguments.\r
 362     //\r
 363     ASSERT(ulBase == QEI_BASE);\r
 364     ASSERT(!(ulPreDiv & ~(QEI_CTL_VELDIV_M)));\r
 365     ASSERT(ulPeriod != 0);\r
 366 \r
 367     //\r
 368     // Set the velocity predivider.\r
 369     //\r
 370     HWREG(ulBase + QEI_O_CTL) = ((HWREG(ulBase + QEI_O_CTL) &\r
 371                                   ~(QEI_CTL_VELDIV_M)) | ulPreDiv);\r
 372 \r
 373     //\r
 374     // Set the timer period.\r
 375     //\r
 376     HWREG(ulBase + QEI_O_LOAD) = ulPeriod - 1;\r
 377 }\r
 378 #endif\r
 379 \r
 380 //*****************************************************************************\r
 381 //\r
 382 //! Gets the current encoder speed.\r
 383 //!\r
 384 //! \param ulBase is the base address of the quadrature encoder module.\r
 385 //!\r
 386 //! This returns the current speed of the encoder.  The value returned is the\r
 387 //! number of pulses detected in the specified time period; this number can be\r
 388 //! multiplied by the number of time periods per second and divided by the\r
 389 //! number of pulses per revolution to obtain the number of revolutions per\r
 390 //! second.\r
 391 //!\r
 392 //! \return The number of pulses captured in the given time period.\r
 393 //\r
 394 //*****************************************************************************\r
 395 #if defined(GROUP_velocityget) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 396 unsigned long\r
 397 QEIVelocityGet(unsigned long ulBase)\r
 398 {\r
 399     //\r
 400     // Check the arguments.\r
 401     //\r
 402     ASSERT(ulBase == QEI_BASE);\r
 403 \r
 404     //\r
 405     // Return the speed capture value.\r
 406     //\r
 407     return(HWREG(ulBase + QEI_O_SPEED));\r
 408 }\r
 409 #endif\r
 410 \r
 411 //*****************************************************************************\r
 412 //\r
 413 //! Registers an interrupt handler for the quadrature encoder interrupt.\r
 414 //!\r
 415 //! \param ulBase is the base address of the quadrature encoder module.\r
 416 //! \param pfnHandler is a pointer to the function to be called when the\r
 417 //! quadrature encoder interrupt occurs.\r
 418 //!\r
 419 //! This sets the handler to be called when a quadrature encoder interrupt\r
 420 //! occurs.  This will enable the global interrupt in the interrupt controller;\r
 421 //! specific quadrature encoder interrupts must be enabled via QEIIntEnable().\r
 422 //! It is the interrupt handler's responsibility to clear the interrupt source\r
 423 //! via QEIIntClear().\r
 424 //!\r
 425 //! \sa IntRegister() for important information about registering interrupt\r
 426 //! handlers.\r
 427 //!\r
 428 //! \return None.\r
 429 //\r
 430 //*****************************************************************************\r
 431 #if defined(GROUP_intregister) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 432 void\r
 433 QEIIntRegister(unsigned long ulBase, void (*pfnHandler)(void))\r
 434 {\r
 435     //\r
 436     // Check the arguments.\r
 437     //\r
 438     ASSERT(ulBase == QEI_BASE);\r
 439 \r
 440     //\r
 441     // Register the interrupt handler, returning an error if an error occurs.\r
 442     //\r
 443     IntRegister(INT_QEI, pfnHandler);\r
 444 \r
 445     //\r
 446     // Enable the quadrature encoder interrupt.\r
 447     //\r
 448     IntEnable(INT_QEI);\r
 449 }\r
 450 #endif\r
 451 \r
 452 //*****************************************************************************\r
 453 //\r
 454 //! Unregisters an interrupt handler for the quadrature encoder interrupt.\r
 455 //!\r
 456 //! \param ulBase is the base address of the quadrature encoder module.\r
 457 //!\r
 458 //! This function will clear the handler to be called when a quadrature encoder\r
 459 //! interrupt occurs.  This will also mask off the interrupt in the interrupt\r
 460 //! controller so that the interrupt handler no longer is called.\r
 461 //!\r
 462 //! \sa IntRegister() for important information about registering interrupt\r
 463 //! handlers.\r
 464 //!\r
 465 //! \return None.\r
 466 //\r
 467 //*****************************************************************************\r
 468 #if defined(GROUP_intunregister) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 469 void\r
 470 QEIIntUnregister(unsigned long ulBase)\r
 471 {\r
 472     //\r
 473     // Check the arguments.\r
 474     //\r
 475     ASSERT(ulBase == QEI_BASE);\r
 476 \r
 477     //\r
 478     // Disable the interrupt.\r
 479     //\r
 480     IntDisable(INT_QEI);\r
 481 \r
 482     //\r
 483     // Unregister the interrupt handler.\r
 484     //\r
 485     IntUnregister(INT_QEI);\r
 486 }\r
 487 #endif\r
 488 \r
 489 //*****************************************************************************\r
 490 //\r
 491 //! Enables individual quadrature encoder interrupt sources.\r
 492 //!\r
 493 //! \param ulBase is the base address of the quadrature encoder module.\r
 494 //! \param ulIntFlags is a bit mask of the interrupt sources to be enabled.\r
 495 //! Can be any of the QEI_INTERROR, QEI_INTDIR, QEI_INTTIMER, or QEI_INTINDEX\r
 496 //! values.\r
 497 //!\r
 498 //! Enables the indicated quadrature encoder interrupt sources.  Only the\r
 499 //! sources that are enabled can be reflected to the processor interrupt;\r
 500 //! disabled sources have no effect on the processor.\r
 501 //!\r
 502 //! \return None.\r
 503 //\r
 504 //*****************************************************************************\r
 505 #if defined(GROUP_intenable) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 506 void\r
 507 QEIIntEnable(unsigned long ulBase, unsigned long ulIntFlags)\r
 508 {\r
 509     //\r
 510     // Check the arguments.\r
 511     //\r
 512     ASSERT(ulBase == QEI_BASE);\r
 513 \r
 514     //\r
 515     // Enable the specified interrupts.\r
 516     //\r
 517     HWREG(ulBase + QEI_O_INTEN) |= ulIntFlags;\r
 518 }\r
 519 #endif\r
 520 \r
 521 //*****************************************************************************\r
 522 //\r
 523 //! Disables individual quadrature encoder interrupt sources.\r
 524 //!\r
 525 //! \param ulBase is the base address of the quadrature encoder module.\r
 526 //! \param ulIntFlags is a bit mask of the interrupt sources to be disabled.\r
 527 //! Can be any of the QEI_INTERROR, QEI_INTDIR, QEI_INTTIMER, or QEI_INTINDEX\r
 528 //! values.\r
 529 //!\r
 530 //! Disables the indicated quadrature encoder interrupt sources.  Only the\r
 531 //! sources that are enabled can be reflected to the processor interrupt;\r
 532 //! disabled sources have no effect on the processor.\r
 533 //!\r
 534 //! \return None.\r
 535 //\r
 536 //*****************************************************************************\r
 537 #if defined(GROUP_intdisable) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 538 void\r
 539 QEIIntDisable(unsigned long ulBase, unsigned long ulIntFlags)\r
 540 {\r
 541     //\r
 542     // Check the arguments.\r
 543     //\r
 544     ASSERT(ulBase == QEI_BASE);\r
 545 \r
 546     //\r
 547     // Disable the specified interrupts.\r
 548     //\r
 549     HWREG(ulBase + QEI_O_INTEN) &= ~(ulIntFlags);\r
 550 }\r
 551 #endif\r
 552 \r
 553 //*****************************************************************************\r
 554 //\r
 555 //! Gets the current interrupt status.\r
 556 //!\r
 557 //! \param ulBase is the base address of the quadrature encoder module.\r
 558 //! \param bMasked is false if the raw interrupt status is required and true if\r
 559 //! the masked interrupt status is required.\r
 560 //!\r
 561 //! This returns the interrupt status for the quadrature encoder module.\r
 562 //! Either the raw interrupt status or the status of interrupts that are\r
 563 //! allowed to reflect to the processor can be returned.\r
 564 //!\r
 565 //! \return The current interrupt status, enumerated as a bit field of\r
 566 //! QEI_INTERROR, QEI_INTDIR, QEI_INTTIMER, and QEI_INTINDEX.\r
 567 //\r
 568 //*****************************************************************************\r
 569 #if defined(GROUP_intstatus) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 570 unsigned long\r
 571 QEIIntStatus(unsigned long ulBase, tBoolean bMasked)\r
 572 {\r
 573     //\r
 574     // Check the arguments.\r
 575     //\r
 576     ASSERT(ulBase == QEI_BASE);\r
 577 \r
 578     //\r
 579     // Return either the interrupt status or the raw interrupt status as\r
 580     // requested.\r
 581     //\r
 582     if(bMasked)\r
 583     {\r
 584         return(HWREG(ulBase + QEI_O_ISC));\r
 585     }\r
 586     else\r
 587     {\r
 588         return(HWREG(ulBase + QEI_O_RIS));\r
 589     }\r
 590 }\r
 591 #endif\r
 592 \r
 593 //*****************************************************************************\r
 594 //\r
 595 //! Clears quadrature encoder interrupt sources.\r
 596 //!\r
 597 //! \param ulBase is the base address of the quadrature encoder module.\r
 598 //! \param ulIntFlags is a bit mask of the interrupt sources to be cleared.\r
 599 //! Can be any of the QEI_INTERROR, QEI_INTDIR, QEI_INTTIMER, or QEI_INTINDEX\r
 600 //! values.\r
 601 //!\r
 602 //! The specified quadrature encoder interrupt sources are cleared, so that\r
 603 //! they no longer assert.  This must be done in the interrupt handler to keep\r
 604 //! it from being called again immediately upon exit.\r
 605 //!\r
 606 //! \return None.\r
 607 //\r
 608 //*****************************************************************************\r
 609 #if defined(GROUP_intclear) || defined(BUILD_ALL) || defined(DOXYGEN)\r
 610 void\r
 611 QEIIntClear(unsigned long ulBase, unsigned long ulIntFlags)\r
 612 {\r
 613     //\r
 614     // Check the arguments.\r
 615     //\r
 616     ASSERT(ulBase == QEI_BASE);\r
 617 \r
 618     //\r
 619     // Clear the requested interrupt sources.\r
 620     //\r
 621     HWREG(ulBase + QEI_O_ISC) = ulIntFlags;\r
 622 }\r
 623 #endif\r
 624 \r
 625 //*****************************************************************************\r
 626 //\r
 627 // Close the Doxygen group.\r
 628 //! @}\r
 629 //\r
 630 //*****************************************************************************\r