Alexan E
blinky example from NXP code bundle for LPC11Uxx. No mbed library used
Diff: KEIL_LPC11U_COMMON_LIB/timer32.c
- Revision:
- 1:0f1be4e75668
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/KEIL_LPC11U_COMMON_LIB/timer32.c Mon May 28 00:13:23 2012 +0000
@@ -0,0 +1,649 @@
+/****************************************************************************
+ * $Id:: timer32.c 9190 2012-02-16 20:59:45Z nxp41306 $
+ * Project: NXP LPC11Uxx 32-bit timer example
+ *
+ * Description:
+ * This file contains 32-bit timer code example which include timer
+ * initialization, timer interrupt handler, and related APIs for
+ * timer setup.
+*
+****************************************************************************
+* Software that is described herein is for illustrative purposes only
+* which provides customers with programming information regarding the
+* products. This software is supplied "AS IS" without any warranties.
+* NXP Semiconductors assumes no responsibility or liability for the
+* use of the software, conveys no license or title under any patent,
+* copyright, or mask work right to the product. NXP Semiconductors
+* reserves the right to make changes in the software without
+* notification. NXP Semiconductors also make no representation or
+* warranty that such application will be suitable for the specified
+* use without further testing or modification.
+
+* Permission to use, copy, modify, and distribute this software and its
+* documentation is hereby granted, under NXP Semiconductors'
+* relevant copyright in the software, without fee, provided that it
+* is used in conjunction with NXP Semiconductors microcontrollers. This
+* copyright, permission, and disclaimer notice must appear in all copies of
+* this code.
+
+****************************************************************************/
+
+#include "LPC11Uxx.h"
+#include "timer32.h"
+#include "nmi.h"
+
+volatile uint32_t timer32_0_counter[4] = {0,0,0,0};
+volatile uint32_t timer32_1_counter[4] = {0,0,0,0};
+volatile uint32_t timer32_0_capture[4] = {0,0,0,0};
+volatile uint32_t timer32_1_capture[4] = {0,0,0,0};
+volatile uint32_t timer32_0_period = 0;
+volatile uint32_t timer32_1_period = 0;
+
+/*****************************************************************************
+** Function name: delay32Ms
+**
+** Descriptions: Start the timer delay in milo seconds
+** until elapsed
+**
+** parameters: timer number, Delay value in milo second
+**
+** Returned value: None
+**
+*****************************************************************************/
+void delay32Ms(uint8_t timer_num, uint32_t delayInMs)
+{
+ if (timer_num == 0)
+ {
+ /* setup timer #0 for delay */
+ LPC_CT32B0->TCR = 0x02; /* reset timer */
+ LPC_CT32B0->PR = 0x00; /* set prescaler to zero */
+ LPC_CT32B0->MR0 = delayInMs * (SystemCoreClock / 1000);
+ LPC_CT32B0->IR = 0xff; /* reset all interrrupts */
+ LPC_CT32B0->MCR = 0x04; /* stop timer on match */
+ LPC_CT32B0->TCR = 0x01; /* start timer */
+
+ /* wait until delay time has elapsed */
+ while (LPC_CT32B0->TCR & 0x01);
+ }
+ else if (timer_num == 1)
+ {
+ /* setup timer #1 for delay */
+ LPC_CT32B1->TCR = 0x02; /* reset timer */
+ LPC_CT32B1->PR = 0x00; /* set prescaler to zero */
+ LPC_CT32B1->MR0 = delayInMs * (SystemCoreClock / 1000);
+ LPC_CT32B1->IR = 0xff; /* reset all interrrupts */
+ LPC_CT32B1->MCR = 0x04; /* stop timer on match */
+ LPC_CT32B1->TCR = 0x01; /* start timer */
+
+ /* wait until delay time has elapsed */
+ while (LPC_CT32B1->TCR & 0x01);
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: TIMER32_0_IRQHandler
+**
+** Descriptions: Timer/CounterX and captureX interrupt handler
+**
+** parameters: None
+** Returned value: None
+**
+******************************************************************************/
+void TIMER32_0_IRQHandler(void)
+{
+ if ( LPC_CT32B0->IR & (0x01<<0) )
+ {
+ LPC_CT32B0->IR = 0x1<<0; /* clear interrupt flag */
+ timer32_0_counter[0]++;
+ }
+ if ( LPC_CT32B0->IR & (0x01<<1) )
+ {
+ LPC_CT32B0->IR = 0x1<<1; /* clear interrupt flag */
+ timer32_0_counter[1]++;
+ }
+ if ( LPC_CT32B0->IR & (0x01<<2) )
+ {
+ LPC_CT32B0->IR = 0x1<<2; /* clear interrupt flag */
+ timer32_0_counter[2]++;
+ }
+ if ( LPC_CT32B0->IR & (0x01<<3) )
+ {
+ LPC_CT32B0->IR = 0x1<<3; /* clear interrupt flag */
+ timer32_0_counter[3]++;
+ }
+ if ( LPC_CT32B0->IR & (0x1<<4) )
+ {
+ LPC_CT32B0->IR = 0x1<<4; /* clear interrupt flag */
+ timer32_0_capture[0]++;
+ }
+ if ( LPC_CT32B0->IR & (0x1<<5) )
+ {
+ LPC_CT32B0->IR = 0x1<<5; /* clear interrupt flag */
+ timer32_0_capture[1]++;
+ }
+ if ( LPC_CT32B0->IR & (0x1<<6) )
+ {
+ LPC_CT32B0->IR = 0x1<<6; /* clear interrupt flag */
+ timer32_0_capture[2]++;
+ }
+ if ( LPC_CT32B0->IR & (0x1<<7) )
+ {
+ LPC_CT32B0->IR = 0x1<<7; /* clear interrupt flag */
+ timer32_0_capture[3]++;
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: TIMER32_1_IRQHandler
+**
+** Descriptions: Timer/CounterX and captureX interrupt handler
+**
+** parameters: None
+** Returned value: None
+**
+******************************************************************************/
+void TIMER32_1_IRQHandler(void)
+{
+ if ( LPC_CT32B1->IR & (0x01<<0) )
+ {
+ LPC_CT32B1->IR = 0x1<<0; /* clear interrupt flag */
+ timer32_1_counter[0]++;
+ }
+ if ( LPC_CT32B1->IR & (0x01<<1) )
+ {
+ LPC_CT32B1->IR = 0x1<<1; /* clear interrupt flag */
+ timer32_1_counter[1]++;
+ }
+ if ( LPC_CT32B1->IR & (0x01<<2) )
+ {
+ LPC_CT32B1->IR = 0x1<<2; /* clear interrupt flag */
+ timer32_1_counter[2]++;
+ }
+ if ( LPC_CT32B1->IR & (0x01<<3) )
+ {
+ LPC_CT32B1->IR = 0x1<<3; /* clear interrupt flag */
+ timer32_1_counter[3]++;
+ }
+ if ( LPC_CT32B1->IR & (0x1<<4) )
+ {
+ LPC_CT32B1->IR = 0x1<<4; /* clear interrupt flag */
+ timer32_1_capture[0]++;
+ }
+ if ( LPC_CT32B1->IR & (0x1<<5) )
+ {
+ LPC_CT32B1->IR = 0x1<<5; /* clear interrupt flag */
+ timer32_1_capture[1]++;
+ }
+ if ( LPC_CT32B1->IR & (0x1<<6) )
+ {
+ LPC_CT32B1->IR = 0x1<<6; /* clear interrupt flag */
+ timer32_1_capture[2]++;
+ }
+ if ( LPC_CT32B1->IR & (0x1<<7) )
+ {
+ LPC_CT32B1->IR = 0x1<<7; /* clear interrupt flag */
+ timer32_1_capture[3]++;
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: enable_timer
+**
+** Descriptions: Enable timer
+**
+** parameters: timer number: 0 or 1
+** Returned value: None
+**
+******************************************************************************/
+void enable_timer32(uint8_t timer_num)
+{
+ if ( timer_num == 0 )
+ {
+ LPC_CT32B0->TCR = 1;
+ }
+ else
+ {
+ LPC_CT32B1->TCR = 1;
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: disable_timer
+**
+** Descriptions: Disable timer
+**
+** parameters: timer number: 0 or 1
+** Returned value: None
+**
+******************************************************************************/
+void disable_timer32(uint8_t timer_num)
+{
+ if ( timer_num == 0 )
+ {
+ LPC_CT32B0->TCR = 0;
+ }
+ else
+ {
+ LPC_CT32B1->TCR = 0;
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: reset_timer
+**
+** Descriptions: Reset timer
+**
+** parameters: timer number: 0 or 1
+** Returned value: None
+**
+******************************************************************************/
+void reset_timer32(uint8_t timer_num)
+{
+ uint32_t regVal;
+
+ if ( timer_num == 0 )
+ {
+ regVal = LPC_CT32B0->TCR;
+ regVal |= 0x02;
+ LPC_CT32B0->TCR = regVal;
+ }
+ else
+ {
+ regVal = LPC_CT32B1->TCR;
+ regVal |= 0x02;
+ LPC_CT32B1->TCR = regVal;
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: set_timer_capture
+**
+** Descriptions: Set timer capture based on location
+**
+** parameters: timer number: 0~1, location 0~2
+** Returned value: None
+**
+******************************************************************************/
+void set_timer32_capture(uint8_t timer_num, uint8_t location )
+{
+ if ( timer_num == 0 )
+ {
+ /* Timer0_32 I/O config */
+ if ( location == 0 )
+ {
+ LPC_IOCON->PIO1_28 &= ~0x07;
+ LPC_IOCON->PIO1_28 |= 0x01; /* Timer0_32 CAP0 */
+ LPC_IOCON->PIO1_29 &= ~0x07;
+ LPC_IOCON->PIO1_29 |= 0x02; /* Timer0_32 CAP1 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->PIO0_17 &= ~0x07;
+ LPC_IOCON->PIO0_17 |= 0x02; /* Timer0_32 CAP0 */
+ }
+ else
+ {
+ while ( 1 ); /* Fatal location number error */
+ }
+ }
+ else
+ {
+ /* Timer1_32 I/O config */
+ if ( location == 0 )
+ {
+// LPC_IOCON->PIO1_4 &= ~0x07; /* Timer1_32 I/O config */
+// LPC_IOCON->PIO1_4 |= 0x01; /* Timer1_32 CAP0 */
+// LPC_IOCON->PIO1_5 &= ~0x07;
+// LPC_IOCON->PIO1_5 |= 0x01; /* Timer1_32 CAP1 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->TMS_PIO0_12 &= ~0x07;
+ LPC_IOCON->TMS_PIO0_12 |= 0x03; /* Timer1_32 CAP0 */
+ }
+ else
+ {
+ while ( 1 ); /* Fatal location number error */
+ }
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: set_timer_match
+**
+** Descriptions: Set timer match based on location
+**
+** parameters: timer number: 0~1, location 0~2
+** Returned value: None
+**
+******************************************************************************/
+void set_timer32_match(uint8_t timer_num, uint8_t match_enable, uint8_t location)
+{
+ if ( timer_num == 0 )
+ {
+ if ( match_enable & 0x01 )
+ {
+ if ( location == 0 )
+ {
+ LPC_IOCON->PIO0_18 &= ~0x07;
+ LPC_IOCON->PIO0_18 |= 0x02; /* Timer0_32 MAT0 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->PIO1_24 &= ~0x07;
+ LPC_IOCON->PIO1_24 |= 0x01; /* Timer0_32 MAT0 */
+ }
+ }
+ if ( match_enable & 0x02 )
+ {
+ if ( location == 0 )
+ {
+ LPC_IOCON->PIO0_19 &= ~0x07;
+ LPC_IOCON->PIO0_19 |= 0x02; /* Timer0_32 MAT1 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->PIO1_25 &= ~0x07;
+ LPC_IOCON->PIO1_25 |= 0x01; /* Timer0_32 MAT1 */
+ }
+ }
+ if ( match_enable & 0x04 )
+ {
+ if ( location == 0 )
+ {
+ LPC_IOCON->PIO0_1 &= ~0x07;
+ LPC_IOCON->PIO0_1 |= 0x02; /* Timer0_32 MAT2 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->PIO1_26 &= ~0x07;
+ LPC_IOCON->PIO1_26 |= 0x01; /* Timer0_32 MAT2 */
+ }
+ }
+ if ( match_enable & 0x08 )
+ {
+ if ( location == 0 )
+ {
+ LPC_IOCON->TDI_PIO0_11 &= ~0x07;
+ LPC_IOCON->TDI_PIO0_11 |= 0x03; /* Timer0_32 MAT3 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->PIO1_27 &= ~0x07;
+ LPC_IOCON->PIO1_27 |= 0x01; /* Timer0_32 MAT3 */
+ }
+ }
+ }
+ else if ( timer_num == 1 )
+ {
+ if ( match_enable & 0x01 )
+ {
+ if ( location == 0 )
+ {
+// LPC_IOCON->PIO1_0 &= ~0x07;
+// LPC_IOCON->PIO1_0 |= 0x01; /* Timer1_32 MAT0 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->TDO_PIO0_13 &= ~0x07;
+ LPC_IOCON->TDO_PIO0_13 |= 0x03; /* Timer1_32 MAT0 */
+ }
+ }
+ if ( match_enable & 0x02 )
+ {
+ if ( location == 0 )
+ {
+// LPC_IOCON->PIO1_1 &= ~0x07;
+// LPC_IOCON->PIO1_1 |= 0x01; /* Timer1_32 MAT1 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->TRST_PIO0_14 &= ~0x07;
+ LPC_IOCON->TRST_PIO0_14 |= 0x03; /* Timer1_32 MAT1 */
+ }
+ }
+ if ( match_enable & 0x04 )
+ {
+ if ( location == 0 )
+ {
+// LPC_IOCON->PIO1_2 &= ~0x07;
+// LPC_IOCON->PIO1_2 |= 0x01; /* Timer1_32 MAT2 */
+ }
+ else if ( location == 1 )
+ {
+#if __SWD_DISABLED
+ LPC_IOCON->SWDIO_PIO0_15 &= ~0x07;
+ LPC_IOCON->SWDIO_PIO0_15 |= 0x03; /* Timer1_32 MAT2 */
+#endif
+ }
+ }
+ if ( match_enable & 0x08 )
+ {
+ if ( location == 0 )
+ {
+// LPC_IOCON->PIO1_3 &= ~0x07;
+// LPC_IOCON->PIO1_3 |= 0x01; /* Timer1_32 MAT3 */
+ }
+ else if ( location == 1 )
+ {
+ LPC_IOCON->PIO0_16 &= ~0x07;
+ LPC_IOCON->PIO0_16 |= 0x02; /* Timer1_32 MAT3 */
+ }
+ }
+ }
+ return;
+}
+
+/******************************************************************************
+** Function name: init_timer
+**
+** Descriptions: Initialize timer, set timer interval, reset timer,
+** install timer interrupt handler
+**
+** parameters: timer number and timer interval
+** Returned value: None
+**
+******************************************************************************/
+void init_timer32(uint8_t timer_num, uint32_t TimerInterval)
+{
+ uint32_t i;
+
+ if ( timer_num == 0 )
+ {
+ /* Some of the I/O pins need to be clearfully planned if
+ you use below module because JTAG and TIMER CAP/MAT pins are muxed. */
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9);
+
+ LPC_CT32B0->MR0 = TimerInterval;
+#if TIMER_MATCH
+ for ( i = 0; i < 4; i++ )
+ {
+ timer32_0_counter[i] = 0;
+ }
+ set_timer32_match(timer_num, 0x0F, 0);
+ LPC_CT32B0->EMR &= ~(0xFF<<4);
+ LPC_CT32B0->EMR |= ((0x3<<4)|(0x3<<6)|(0x3<<8)|(0x3<<10)); /* MR0/1/2/3 Toggle */
+#else
+ for ( i = 0; i < 4; i++ )
+ {
+ timer32_0_capture[i] = 0;
+ }
+ set_timer32_capture(timer_num, 0 );
+ /* Capture 0 on rising edge, interrupt enable. */
+ LPC_CT32B0->CCR = (0x5<<0)|(0x5<<3);
+#endif
+ LPC_CT32B0->MCR = 3; /* Interrupt and Reset on MR0 */
+
+ /* Enable the TIMER0 Interrupt */
+#if NMI_ENABLED
+ NVIC_DisableIRQ( TIMER_32_0_IRQn );
+ NMI_Init( TIMER_32_0_IRQn );
+#else
+ NVIC_EnableIRQ(TIMER_32_0_IRQn);
+#endif
+ }
+ else if ( timer_num == 1 )
+ {
+ /* Some of the I/O pins need to be clearfully planned if
+ you use below module because JTAG and TIMER CAP/MAT pins are muxed. */
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<10);
+
+ LPC_CT32B1->MR0 = TimerInterval;
+#if TIMER_MATCH
+ for ( i = 0; i < 4; i++ )
+ {
+ timer32_1_counter[i] = 0;
+ }
+ set_timer32_match(timer_num, 0x0F, 0);
+ LPC_CT32B1->EMR &= ~(0xFF<<4);
+ LPC_CT32B1->EMR |= ((0x3<<4)|(0x3<<6)|(0x3<<8)|(0x3<<10)); /* MR0/1/2 Toggle */
+#else
+ for ( i = 0; i < 4; i++ )
+ {
+ timer32_1_capture[i] = 0;
+ }
+ set_timer32_capture(timer_num, 0 );
+ /* Capture 0 on rising edge, interrupt enable. */
+ LPC_CT32B1->CCR = (0x5<<0)|(0x5<<3);
+#endif
+ LPC_CT32B1->MCR = 3; /* Interrupt and Reset on MR0 */
+
+ /* Enable the TIMER1 Interrupt */
+#if NMI_ENABLED
+ NVIC_DisableIRQ( TIMER_32_1_IRQn );
+ NMI_Init( TIMER_32_1_IRQn );
+#else
+ NVIC_EnableIRQ(TIMER_32_1_IRQn);
+#endif
+ }
+ return;
+}
+/******************************************************************************
+** Function name: init_timer32PWM
+**
+** Descriptions: Initialize timer as PWM
+**
+** parameters: timer number, period and match enable:
+** match_enable[0] = PWM for MAT0
+** match_enable[1] = PWM for MAT1
+** match_enable[2] = PWM for MAT2
+** Returned value: None
+**
+******************************************************************************/
+void init_timer32PWM(uint8_t timer_num, uint32_t period, uint8_t match_enable)
+{
+ disable_timer32(timer_num);
+ if (timer_num == 1)
+ {
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<10);
+
+ /* Setup the external match register */
+ LPC_CT32B1->EMR = (1<<EMC3)|(1<<EMC2)|(2<<EMC1)|(1<<EMC0)|MATCH3|(match_enable);
+
+ /* Setup the outputs */
+ /* If match0 is enabled, set the output, use location 0 for test. */
+ set_timer32_match( timer_num, match_enable, 0 );
+
+ /* Enable the selected PWMs and enable Match3 */
+ LPC_CT32B1->PWMC = MATCH3|(match_enable);
+
+ /* Setup the match registers */
+ /* set the period value to a global variable */
+ timer32_1_period = period;
+ LPC_CT32B1->MR3 = timer32_1_period;
+ LPC_CT32B1->MR0 = timer32_1_period/2;
+ LPC_CT32B1->MR1 = timer32_1_period/2;
+ LPC_CT32B1->MR2 = timer32_1_period/2;
+ LPC_CT32B1->MCR = 1<<10; /* Reset on MR3 */
+ }
+ else
+ {
+ /* Some of the I/O pins need to be clearfully planned if
+ you use below module because JTAG and TIMER CAP/MAT pins are muxed. */
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9);
+
+ /* Setup the external match register */
+ LPC_CT32B0->EMR = (1<<EMC3)|(2<<EMC2)|(1<<EMC1)|(1<<EMC0)|MATCH3|(match_enable);
+
+ /* Setup the outputs */
+ /* If match0 is enabled, set the output, use location 0 for test. */
+ set_timer32_match( timer_num, match_enable, 0 );
+
+ /* Enable the selected PWMs and enable Match3 */
+ LPC_CT32B0->PWMC = MATCH3|(match_enable);
+
+ /* Setup the match registers */
+ /* set the period value to a global variable */
+ timer32_0_period = period;
+ LPC_CT32B0->MR3 = timer32_0_period;
+ LPC_CT32B0->MR0 = timer32_0_period/2;
+ LPC_CT32B0->MR1 = timer32_0_period/2;
+ LPC_CT32B0->MR2 = timer32_0_period/2;
+ LPC_CT32B0->MCR = 1<<10; /* Reset on MR3 */
+ }
+}
+
+/******************************************************************************
+** Function name: pwm32_setMatch
+**
+** Descriptions: Set the pwm32 match values
+**
+** parameters: timer number, match numner and the value
+**
+** Returned value: None
+**
+******************************************************************************/
+void setMatch_timer32PWM (uint8_t timer_num, uint8_t match_nr, uint32_t value)
+{
+ if (timer_num)
+ {
+ switch (match_nr)
+ {
+ case 0:
+ LPC_CT32B1->MR0 = value;
+ break;
+ case 1:
+ LPC_CT32B1->MR1 = value;
+ break;
+ case 2:
+ LPC_CT32B1->MR2 = value;
+ break;
+ case 3:
+ LPC_CT32B1->MR3 = value;
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ {
+ switch (match_nr)
+ {
+ case 0:
+ LPC_CT32B0->MR0 = value;
+ break;
+ case 1:
+ LPC_CT32B0->MR1 = value;
+ break;
+ case 2:
+ LPC_CT32B0->MR2 = value;
+ break;
+ case 3:
+ LPC_CT32B0->MR3 = value;
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+/******************************************************************************
+** End Of File
+******************************************************************************/