Timer counter in arm7(lpc2148)

Timer Counter in ARM7(LPC2148)
By-
Aarav Soni

What is Timer ?
• Timer is fully depend upon the oscillator that attached externally to the
microcontroller because it uses the frequency of oscillator to operate.
• When we trigger timer it start from initial value and run up to decided value
stored by user in special function registers. When it reach its maximum
value, it overflows and a certain bit is decided to show over flow in
SFR(special function register) also called flag bit.
• Some timers also used prescalar technique to enhance its limits.
• Suppose a timer is of 8 bit so it can achieved up to = 256 (2^8)
• for 16 bit so it can achieved up to = 65536 (2^16).
• For 32 bit so it can achieved up to = 2^32.

Timer in LPC2148
• The LPC2148 has two functionally identical general purpose timers:
Timer0 and Timer1.
• Both Timer/Counter with a programmable 32-bit Prescaler.
• Counter or Timer operation.
• Up to four 32-bit capture channels per timer, that can take a snapshot of the
timer value when an input signal transitions. A capture event may also
optionally generate an interrupt.
• Four 32-bit match registers that allow:
– Continuous operation with optional interrupt generation on match.
– Stop timer on match with optional interrupt generation.
– Reset timer on match with optional interrupt generation

• Up to four external outputs corresponding to match registers, with the
following capabilities:
– Set low on match.
– Set high on match.
– Toggle on match.
– Do nothing on match.
Capture Register: As the name suggests it is used to Capture Input signal.
When a transition event occurs on a Capture pin , it can be used to copy the
value of TC into any of the 4 Capture Register or to genreate an Interrupt.
Hence these can be also used to demodulated PWM signals.
Match Register:
• A Match Register is a Register which contains a specific value set by the
user. When the Timer starts – every time after TC is incremented the value
in TC is compared with match register. If it matches then it can Reset the
Timer or can generate an interrupt as defined by the user. We are only
concerned with match registers in this PPT.

How Timers in LPC2148 ARM7 Microcontroller
Works?
• The heart of timers of the LPC2148 Microcontroller is a 32-bit free
running counter, which is designed to count cycles of the Peripheral
Clock (PCLK) or an external clock, this counter is programmable with
32-bit prescaler.
PCLK
Prescale
Counter
Timer
Counter

• The tick rate of the Timer Counter (TC) is controlled by the 32-bit number
written in the Prescaler Register (PR) in the following way.
• There is a Prescale Counter (PC) which increments on each tick of the
PCLK.
• When it reaches the value in the Prescaler register, the timer count is
incremented and the Prescaler Counter (PC) is reset, on the next PCLK.
• This cause the timer counters to increment on every PCLK when PR=0,
every 2 PCLKs when PR=1, etc.

Timer counter in arm7(lpc2148)

The Match register values are continuously compared to the Timer Counter
value, when the two values are equal, actions ( Match pin / Interrupt ) can be
triggered automatically

Timer Control Register (TCR, TIMER0: T0TCR)
Timer Control register used to control the timer control functions. We’ll
enable, disable and reset Timer Counter (TC) through this register

Count Control Register (CTCR, TIMER0: T0CTCR)
The Count Control Register (CTCR) is used to select between Timer and
Counter mode, and in Counter mode to select the pin and edge(s) for
counting.

Timer Counter (TC, Timer0: T0CR):
• This is the main counting register. Timer Counter increments when PC
reaches its maximum value as specified by PR. If timer is not reset
explicitly(directly) or by using an interrupt then it will act as a free running
counter which resets back to zero when it reaches its maximum value
which is 0xFFFFFFFF.
Prescale Register (PR, TIMER0: T0PR):
• The 32-bit Prescale Register specifies the maximum value for the Prescale
Counter.
Prescale Counter Register (PC, TIMER0: T0PC):
• This register increments on every PCLK(Peripheral clock). This register
controls the resolution of the timer. When PC reaches the value in PR , PC
is reset back to 0 and Timer Counter is incremented by 1.
• Hence if PR=0 then Timer Counter Increments on every 1 PCLK. If PR=9
then Timer Counter Increments on every 10th cycle of PCLK. Hence by
selecting an appropriate prescale value we can control the resolution of the
timer.

Match Registers (MR0 - MR3):
• The Match register values are continuously compared to the Timer Counter
value. When the two values are equal, actions can be triggered automatically.
• The action possibilities are to generate an interrupt, reset the Timer Counter, or
stop the timer. Actions are controlled by the settings in the MCR register.
Match Control Register (MCR, TIMER0: T0MCR)
• This register is used to control which all operations can be done when the value
in MR matches the value in TC. Bits 0,1,2 are for MR0 , Bits 3,4,5 for MR1
and so on.. Heres a quick table which shows the usage:
For MR0: (Match Register 0)
• Bit 0 : Interrupt on MR0 i.e trigger an interrupt when MR0 matches TC.
Interrupts are enabled when set to 1 and disabled when set to 0.
• Bit 1 : Reset on MR0. When set to 1 , TC will be reset when it matched MR0.
Disabled when set to 0.
• Bit 2 : Stop on MR0. When set to 1 , TC & PC will stop when MR0 matches
TC.
• Similarly bits 3-5 , 6-8 , 9-11 are for MR1 , MR2 , MR3 respectively.

Interrupt Register (IR, TIMER0: T0IR):
• The Interrupt Register consists of four bits for the match
interrupts and four bits for the capture interrupts.

How to calculate value of prescaler ?

Basic Step for Timer
• Set appropriate value in TxCTCR
• Define the Prescale value in TxPR
• Set Value(s) in Match Register(s) if required
• Set appropriate value in TxMCR if using Match registers / Interrupts
• Reset Timer – Which resets PR and TC
• Set TxTCR to 0x01 to Enable the Timer when required
• Reset TxTCR to 0x00 to Disable the Timer when required
Note: where x denote which timer we want to use.

Function for initializing timer0
void initTimer0(void)
{
/*Assuming that PLL0 has been setup with CCLK = 60Mhz and PCLK
also = 60Mhz.*/
T0CTCR = 0x0; // Select timer
T0PR = 60000-1; //(Value in Decimal!) - Increment T0TC at every 60000
clock cycle
//count begins from zero hence subtracting 1
//60000 clock cycles @60Mhz = 1 mS
T0TCR = 0x02; //Reset Timer
}

Function for generating delay
void delay(unsigned int milliseconds) // Using Timer0
{
T0TCR = 0x01; //Enable timer
while(T0TC < milliseconds); //wait until timer counter reaches the
desired delay
T0TCR = 0x00; //Disable timer
}

Program for PLL
void initClocks(void)
{
PLL0CON = 0x01; //Enable PLL
PLL0CFG = 0x24; //Multiplier and divider setup
PLL0FEED = 0xAA; //Feed sequence
PLL0FEED = 0x55;
while(!(PLL0STAT & 0x00000400)); //is locked?
PLL0CON = 0x03; //Connect PLL after PLL is locked
PLL0FEED = 0xAA; //Feed sequence
PLL0FEED = 0x55;
VPBDIV = 0x01; // PCLK is same as CCLK i.e.60 MHz
}

Using interrupt method generating delay
#include <lpc214x.h>
#define MR0I (1<<0) //Interrupt When TC matches MR0
#define MR0R (1<<1) //Reset TC when TC matches MR0
#define DELAY_MS 500 //0.5 Seconds Delay
#define PRESCALE 60000 //60000 PCLK clock cycles to increment TC by 1
void delayMS(unsigned int milliseconds);
void initClocks(void); // PLL Function
void initTimer0(void);
__irq void T0ISR(void); //Interrupt function ISR

int main(void)
{
initClocks(); //Initialize CPU and Peripheral Clocks @ 60Mhz
initTimer0(); //Initialize Timer0
IO0DIR = 0xFFFFFFFF; //Configure all pins on Port 0 as Output
IO0PIN = 0xF;
T0TCR = 0x01; //Enable timer
while(1); //Infinite Idle Loop //return 0; //normally this wont execute ever :P
}

void initTimer0(void)
{
//----------Configure Timer0-------------
T0CTCR = 0x0;
T0PR =60000; //Fosc= 60 Mhz
T0MR0 = DELAY_MS-1;
//(Value in Decimal!) Zero Indexed Count - hence subtracting 1
T0MCR = MR0I | MR0R; //Set bit0 & bit1 to High which is to : Interrupt &
Reset TC on MR0
//----------Setup Timer0 Interrupt-------------
VICVectAddr4 = (unsigned )T0ISR; //Pointer Interrupt Function (ISR)
VICVectCntl4 = 0x20 | 4; //0x20 (i.e bit5 = 1) -> to enable Vectored IRQ slot
//0x4 (bit[4:0]) -> this the source number - here its timer0 which has VIC
channel mask # as
VICIntEnable = 0x10; //Enable timer0 int
}

__irq void T0ISR(void)
{
long int regVal;
regVal = T0IR; //Read current IR value
IO0PIN = ~IO0PIN; //Toggle the state of the Pins
T0IR = regVal; //Write back to IR to clear Interrupt Flag
VICVectAddr = 0x0; //This is to signal end of interrupt execution
}

/* TOGGLE LEDS FROM P0.0 TO P0.15 WITH EXACT DELAY OF 3SEC */
#include<lpc21xx.h>
void delay(void);
int main()
{
VPBDIV=0X02; //30MHZ//
PINSEL0=0X00000000;
IODIR0=0X000000FF;
IOCLR0=0X000000FF;
while(1)
{
IOSET0=0X000000FF;
delay();
IOCLR0=0X000000FF;
delay();
}
}
void delay(void)
{
T0PR=30000;
T0MR0=3000;
T0TC=0x00000000;
T0TCR=0X01; //START TIMER//
while(T0TC !=T0MR0); //1 SEC//
T0TCR=0X02; //STOP TIMER/
}

/* TOGGLE LEDS FROM P0.0 TO P0.7 WITH EXACT DELAY OF 2 SEC BY USING
T0MR3.TOGGLE LEDS FROM P0.15 TO P0.23 WITH EXACT DELAY OF 5 SEC BY USING
T1MR2. */
#include<lpc21xx.h>
void delay1(void);
void delay2(void);
int main()
{
VPBDIV=0X02; //30MHZ//
PINSEL0=0X00000000;
IODIR0=0X00FF00FF;
IOCLR0=0X00FF00FF;
while(1)
{
IOSET0=0X00FF00FF;
delay1();
IOCLR0=0X00FF00FF;
delay2();
}
}

void delay1(void)
{
T0PR=30000;
T0MR0=1000;
T0TC=0x00000000;
T0TCR=0X02; //STOP TIMER/
}
void delay2(void)
{
T1PR=30000;
T1MR2=2000;
T1TC=0x00000000;
T1TCR=0X02; //STOP TIMER//
}

Thanks
For any suggestion,
Please contact me on-
Mail id- a.soniarav@gmail.com
Facebook- https:www.facebook.com/arav.soni.98
Twitter- https://twitter.com/AaravSoni1

Timer counter in arm7(lpc2148)

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Timer counter in arm7(lpc2148) (20)

Recently uploaded (20)

Timer counter in arm7(lpc2148)