core/timer32/timer32.c

   1 /**************************************************************************/
   2 /*!
   3     @file     timer32.c
   4     @author   K. Townsend (microBuilder.eu)
   5     @date     22 March 2010
   6     @version  0.10
   7
   8     @section DESCRIPTION
   9
  10     Generic code for 32-bit timers.  By default, the timers are configured
  11     to generate an interrupt once every 100 microseconds, incrementing a
  12     global variable once per tick.
  13
  14     @warning  Please note that the ROM-based USB drivers on the LPC1343
  15               require the use of 32-bit Timer 1.  If you plan on using the
  16               ROM-based USB functionality, you should restrict your timer
  17               usage to 32-bit timer 0.
  18
  19     @section Example
  20
  21     @code
  22     #include "/core/cpu/cpu.h"
  23     #include "/core/timer32/timer32.h"
  24     ...
  25     cpuInit();
  26
  27     // Initialise 32-bit timer 0 with 100uS ticks
  28     timer32Init(0, TIMER32_DEFAULTINTERVAL);
  29
  30     // Enable timer 0
  31     timer32Enable(0);
  32
  33     // Cause a blocking delay for 1 second (1000mS)
  34     timer32Delay(0, TIMER32_DELAY_1MS * 1000);
  35     @endcode
  36
  37     @section LICENSE
  38
  39     Software License Agreement (BSD License)
  40
  41     Copyright (c) 2010, microBuilder SARL
  42     All rights reserved.
  43
  44     Redistribution and use in source and binary forms, with or without
  45     modification, are permitted provided that the following conditions are met:
  46     1. Redistributions of source code must retain the above copyright
  47     notice, this list of conditions and the following disclaimer.
  48     2. Redistributions in binary form must reproduce the above copyright
  49     notice, this list of conditions and the following disclaimer in the
  50     documentation and/or other materials provided with the distribution.
  51     3. Neither the name of the copyright holders nor the
  52     names of its contributors may be used to endorse or promote products
  53     derived from this software without specific prior written permission.
  54
  55     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
  56     EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  57     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  58     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
  59     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  60     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  61     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  62     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  63     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  64     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  65 */
  66 /**************************************************************************/
  67
  68 #include "timer32.h"
  69
  70 volatile uint32_t timer32_0_counter = 0;
  71 volatile uint32_t timer32_1_counter = 0;
  72 void (*interruptHandler0)(void) = NULL;
  73
  74 /**************************************************************************/
  75 /*!
  76     @brief      Causes a blocking delay for the specified number of
  77                 timer ticks.  The duration of each 'tick' is determined by
  78                 the 'timerInterval' property supplied to timer32Init.
  79
  80     @param[in]  timerNum
  81                 The 32-bit timer to user (0..1)
  82     @param[in]  delay
  83                 The number of counter increments to wait
  84 */
  85 /**************************************************************************/
  86 void timer32Delay(uint8_t timerNum, uint32_t delay)
  87 {
  88   uint32_t curTicks;
  89
  90   if (timerNum == 0)
  91   {
  92     curTicks = timer32_0_counter;
  93     if (curTicks > 0xFFFFFFFF - delay)
  94     {
  95       // Rollover will occur during delay
  96       while (timer32_0_counter >= curTicks)
  97       {
  98         while (timer32_0_counter < (delay - (0xFFFFFFFF - curTicks)));
  99       }
 100     }
 101     else
 102     {
 103       while ((timer32_0_counter - curTicks) < delay);
 104     }
 105   }
 106
 107   else if (timerNum == 1)
 108   {
 109     curTicks = timer32_1_counter;
 110     if (curTicks > 0xFFFFFFFF - delay)
 111     {
 112       // Rollover will occur during delay
 113       while (timer32_1_counter >= curTicks)
 114       {
 115         while (timer32_1_counter < (delay - (0xFFFFFFFF - curTicks)));
 116       }
 117     }
 118     else
 119     {
 120       while ((timer32_1_counter - curTicks) < delay);
 121     }
 122   }
 123
 124   return;
 125 }
 126
 127 /**************************************************************************/
 128 /*!
 129     @brief Interrupt handler for 32-bit timer 0
 130 */
 131 /**************************************************************************/
 132 void TIMER32_0_IRQHandler(void)
 133 {
 134     /* Call the callback function if required */
 135     if(NULL != interruptHandler0)
 136     {
 137         (*interruptHandler0)();
 138     }
 139
 140     /* Clear the interrupt flag */
 141     TMR_TMR32B0IR = TMR_TMR32B0IR_MR0;
 142
 143     /* If you wish to perform some action after each timer 'tick' (such as
 144      incrementing a counter variable) you can do so here */
 145     timer32_0_counter++;
 146
 147     return;
 148 }
 149
 150 /**************************************************************************/
 151 /*!
 152         @brief Interrupt handler for 32-bit timer 1
 153 */
 154 /**************************************************************************/
 155 void TIMER32_1_IRQHandler(void)
 156 {
 157   /* Clear the interrupt flag */
 158   TMR_TMR32B1IR = TMR_TMR32B1IR_MR0;
 159
 160   /* If you wish to perform some action after each timer 'tick' (such as
 161      incrementing a counter variable) you can do so here */
 162   timer32_1_counter++;
 163
 164   return;
 165 }
 166
 167 /**************************************************************************/
 168 /*!
 169     @brief Enables the specified timer
 170
 171     @param[in]  timerNum
 172                 The 32-bit timer to enable (0..1)
 173 */
 174 /**************************************************************************/
 175 void timer32Enable(uint8_t timerNum)
 176 {
 177   if ( timerNum == 0 )
 178   {
 179     TMR_TMR32B0TCR = TMR_TMR32B0TCR_COUNTERENABLE_ENABLED;
 180   }
 181
 182   else if (timerNum == 1)
 183   {
 184     TMR_TMR32B1TCR = TMR_TMR32B1TCR_COUNTERENABLE_ENABLED;
 185   }
 186
 187   return;
 188 }
 189
 190 /**************************************************************************/
 191 /*!
 192     @brief Disables the specified timer
 193
 194     @param[in]  timerNum
 195                 The 32-bit timer to disable (0..1)
 196 */
 197 /**************************************************************************/
 198 void timer32Disable(uint8_t timerNum)
 199 {
 200   if ( timerNum == 0 )
 201   {
 202     TMR_TMR32B0TCR = TMR_TMR32B0TCR_COUNTERENABLE_DISABLED;
 203   }
 204
 205   else if (timerNum == 1)
 206   {
 207     TMR_TMR32B1TCR = TMR_TMR32B1TCR_COUNTERENABLE_DISABLED;
 208   }
 209
 210   return;
 211 }
 212
 213 /**************************************************************************/
 214 /*!
 215     @brief Resets the specified timer
 216
 217     @param[in]  timerNum
 218                 The 32-bit timer to reset (0..1)
 219 */
 220 /**************************************************************************/
 221 void timer32Reset(uint8_t timerNum)
 222 {
 223   uint32_t regVal;
 224
 225   if ( timerNum == 0 )
 226   {
 227     regVal = TMR_TMR32B0TCR;
 228     regVal |= TMR_TMR32B0TCR_COUNTERRESET_ENABLED;
 229     TMR_TMR32B0TCR = regVal;
 230   }
 231
 232   else if (timerNum == 1)
 233   {
 234     regVal = TMR_TMR32B1TCR;
 235     regVal |= TMR_TMR32B1TCR_COUNTERRESET_ENABLED;
 236     TMR_TMR32B1TCR = regVal;
 237   }
 238
 239   return;
 240 }
 241
 242 /**************************************************************************/
 243 /*!
 244     @brief  Initialises the specified 32-bit timer, and configures the
 245             timer to raise an interrupt and reset on match on MR0.
 246
 247     @param[in]  timerNum
 248                 The 32-bit timer to initiliase (0..1)
 249     @param[in]  timerInterval
 250                 The number of clock 'ticks' between resets (0..0xFFFFFFFF)
 251
 252     @note   Care needs to be taken when configuring the timers since the
 253             pins are all multiplexed with other peripherals.  This code is
 254             provided as a starting point, but it will need to be adjusted
 255             according to your own situation and pin/peripheral requirements
 256 */
 257 /**************************************************************************/
 258 void timer32Init(uint8_t timerNum, uint32_t timerInterval)
 259 {
 260   // If timerInterval is invalid, use the default value
 261   if (timerInterval < 1)
 262   {
 263     timerInterval = TIMER32_DEFAULTINTERVAL;
 264   }
 265
 266   if ( timerNum == 0 )
 267   {
 268     /* Enable the clock for CT32B0 */
 269     SCB_SYSAHBCLKCTRL |= (SCB_SYSAHBCLKCTRL_CT32B0);
 270
 271     /* The physical pins associated with CT32B0 are not enabled by
 272        default in order to avoid conflicts with other peripherals.  If
 273        you wish to use any of the pin-dependant functionality, simply
 274        uncomment the appropriate lines below.                             */
 275
 276     /* Configure PIO1.5 as Timer0_32 CAP0 */
 277     // IOCON_PIO1_5 &= ~IOCON_PIO1_5_FUNC_MASK;
 278     // IOCON_PIO1_5 |= IOCON_PIO1_5_FUNC_CT32B0_CAP0;
 279
 280     /* Configure PIO1.6 as Timer0_32 MAT0 */
 281     // IOCON_PIO1_6 &= ~IOCON_PIO1_6_FUNC_MASK;
 282     // IOCON_PIO1_6 |= IOCON_PIO1_6_FUNC_CT32B0_MAT0;
 283
 284     /* Configure PIO1.7 as Timer0_32 MAT1 */
 285     // IOCON_PIO1_7 &= ~IOCON_PIO1_7_FUNC_MASK;
 286     // IOCON_PIO1_7 |= IOCON_PIO1_7_FUNC_CT32B0_MAT1;
 287
 288     /* Configure PIO0.1 as Timer0_32 MAT2 */
 289     // IOCON_PIO0_1 &= ~IOCON_PIO0_1_FUNC_MASK;
 290     // IOCON_PIO0_1 |= IOCON_PIO0_1_FUNC_CT32B0_MAT2;
 291
 292     /* Configure PIO0.11 as Timer0_32 MAT3 */
 293     /* Note: This pint can not be used with JTAG/SWD */
 294     // IOCON_JTAG_TDI_PIO0_11 &= ~IOCON_JTAG_TDI_PIO0_11_FUNC_MASK;
 295     // IOCON_JTAG_TDI_PIO0_11 |= IOCON_JTAG_TDI_PIO0_11_FUNC_CT32B0_MAT3;
 296
 297     timer32_0_counter = 0;
 298     TMR_TMR32B0MR0 = timerInterval;
 299
 300     /* Configure match control register to raise an interrupt and reset on MR0 */
 301     TMR_TMR32B0MCR = (TMR_TMR32B0MCR_MR0_INT_ENABLED | TMR_TMR32B0MCR_MR0_RESET_ENABLED);
 302
 303     /* Enable the TIMER0 interrupt */
 304     NVIC_EnableIRQ(TIMER_32_0_IRQn);
 305   }
 306
 307   else if ( timerNum == 1 )
 308   {
 309     /* Enable the clock for CT32B1 */
 310     SCB_SYSAHBCLKCTRL |= (SCB_SYSAHBCLKCTRL_CT32B1);
 311
 312     /* The physical pins associated with CT32B0 are not enabled by
 313        default in order to avoid conflicts with other peripherals.        */
 314
 315     /* Configure PIO1.0 as Timer1_32 CAP0 */
 316     /* Note: This pint can not be used with JTAG/SWD */
 317     // IOCON_JTAG_TMS_PIO1_0 &= ~IOCON_JTAG_TMS_PIO1_0_FUNC_MASK;
 318     // IOCON_JTAG_TMS_PIO1_0 |= IOCON_JTAG_TMS_PIO1_0_FUNC_CT32B1_CAP0;
 319
 320     /* Configure PIO1.1 as Timer1_32 MAT0 */
 321     /* Note: This pint can not be used with JTAG/SWD */
 322     // IOCON_JTAG_TDO_PIO1_1 &= ~IOCON_JTAG_TDO_PIO1_1_FUNC_MASK;
 323     // IOCON_JTAG_TDO_PIO1_1 |= IOCON_JTAG_TDO_PIO1_1_FUNC_CT32B1_MAT0;
 324
 325     /* Configure PIO1.2 as Timer1_32 MAT1 */
 326     /* Note: This pint can not be used with JTAG/SWD */
 327     // IOCON_JTAG_nTRST_PIO1_2 &= ~IOCON_JTAG_nTRST_PIO1_2_FUNC_MASK;
 328     // IOCON_JTAG_nTRST_PIO1_2 |= IOCON_JTAG_nTRST_PIO1_2_FUNC_CT32B1_MAT1;
 329
 330     /* Configure PIO1.3 as Timer1_32 MAT2 */
 331     /* Note: This pint can not be used with JTAG/SWD */
 332     // IOCON_SWDIO_PIO1_3 &= ~IOCON_SWDIO_PIO1_3_FUNC_MASK;
 333     // IOCON_SWDIO_PIO1_3 |= IOCON_SWDIO_PIO1_3_FUNC_CT32B1_MAT2;
 334
 335     /* Configure PIO1.4 as Timer1_32 MAT3 */
 336     // IOCON_PIO1_4 &= ~IOCON_PIO1_4_FUNC_MASK;
 337     // IOCON_PIO1_4 |= IOCON_PIO1_4_FUNC_CT32B1_MAT3;
 338
 339     timer32_1_counter = 0;
 340     TMR_TMR32B1MR0 = timerInterval;
 341
 342     /* Configure match control register to raise an interrupt and reset on MR0 */
 343     TMR_TMR32B1MCR = (TMR_TMR32B1MCR_MR0_INT_ENABLED | TMR_TMR32B1MCR_MR0_RESET_ENABLED);
 344
 345     /* Enable the TIMER1 Interrupt */
 346     NVIC_EnableIRQ(TIMER_32_1_IRQn);
 347   }
 348   return;
 349 }
 350
 351 /**************************************************************************/
 352 /*!
 353     @brief Sets the optional callback function for 32-bit timer 0
 354
 355     @section EXAMPLE
 356
 357     @code
 358     #include "core/timer32/timer32.h"
 359
 360     static volatile int32_t timerCounter;
 361
 362     // Callback function for 32-bit timer 0
 363     void ct32b0Callback(void)
 364     {
 365       timerCounter++;
 366     }
 367
 368     int main(void)
 369     {
 370       // Configure cpu and mandatory peripherals
 371       systemInit();
 372
 373       // Init timer 0 with 1ms delay
 374       timer32Init(0, TIMER32_CCLK_1MS);
 375
 376       // Setup the interrupt callback
 377       timer32SetIntHandler(ct32b0Callback);
 378
 379       // Enable the timer
 380       timer32Enable(0);
 381
 382       while (1)
 383       {
 384       }
 385     }
 386     @endcode
 387 */
 388 /**************************************************************************/
 389 void timer32SetIntHandler(void (*handler)(void))
 390 {
 391     interruptHandler0 = handler;
 392 }
 393
 394 /**************************************************************************/
 395 /*!
 396     @brief Returns the value of the auto-incrementing timer counter(s)
 397 */
 398 /**************************************************************************/
 399 uint32_t timer32GetCount(uint8_t timerNum)
 400 {
 401     if (0 == timerNum)
 402     {
 403         return timer32_0_counter;
 404     }
 405     else
 406     {
 407         return timer32_1_counter;
 408     }
 409 }
 410
 411 /**************************************************************************/
 412 /*!
 413     @brief Resets the auto-incrementing timer counter(s)
 414 */
 415 /**************************************************************************/
 416 void timer32ResetCounter(uint8_t timerNum)
 417 {
 418     if (0 == timerNum)
 419     {
 420         timer32_0_counter = 0;
 421     }
 422     else if (1 == timerNum)
 423     {
 424         timer32_1_counter = 0;
 425     }
 426 }