C++ Source Code for function definition:

/*Find a prescale given Timer Resolution in Milli-Secs (ms) at CCLK*/
unsigned int calcPrescaleMS(unsigned short resMS) //Argument in ms
{
	if( resMS<1 || resMS>1000 ) return 0; //Accept between 1 and 1000ms only
	SystemCoreClockUpdate();
	float prescale = SystemCoreClock * ((float)resMS/1000);
	return ((unsigned int)prescale - 1);
}

/*Find a prescale given Timer Resolution in Micro-Secs (us) at CCLK*/
unsigned int calcPrescaleUS(unsigned short resUS) //Argument in us
{
	if( resUS<1 || resUS>1000 ) return 0; //Accept between 1 and 1000us only
	SystemCoreClockUpdate();
	float prescale = SystemCoreClock * ((float)resUS/1000000);
	return ((unsigned int)prescale - 1);
}

Example Usage

//Get prescaler value for 1ms Resolution/Delay per TC increment
LPC_TMR32B0->PR = calcPrescaleMS(1);

//Find prescaler value for 10ms Resolution/Delay per TC increment
LPC_TMR32B0->PR = calcPrescaleMS(10);

//Use prescaler value for 1us Resolution/Delay per TC increment
LPC_TMR32B0->PR = calcPrescaleUS(1);

//Get prescaler value for 100us Resolution/Delay per TC increment
LPC_TMR32B0->PR = calcPrescaleUS(100);

The post Function to calculate Prescaler value for LPC1114 & LPC1343 appeared first on OCFreaks!.

Pulse Width Modulation (PWM) Basics:

I’ve have posted a Beginner PWM tutorial. If you are new to PWM please have a look there. A Diagram that sums it up is given below. It shows Single Edge Non-Inverting or Left-Aligned PWM with T_ON, T_OFF & Period. Duty Cycle is simply T_ON Divided by Period.

ARM Cortex-M0 LPC1114 PWM Module

In LPC11xx Microcontrollers a dedicated PWM block is absent. Instead, PWM support is integrated in the Timers themselves. We just need to use them in PWM mode to generate PWM. LPC111x micro-controllers only support Single Edge PWM outputs. More over, the way PWM support is implemented in these microcontrollers, the PWM pulse is Leading-Edge or Right-Aligned compared to Trailing-Edge or Left-Aligned PWM which is more common. But thankfully, this does not change the way we control external PWM controlled devices since Leading-Edge/Right-Aligned PWM is just a Phase-Shifted Left-Aligned pulse – with the only condition that Duty Cycle (hence T_ON) remains the same. Given this condition is satisfied: consider it having a “offset” at the beginning, afterwhich its basically Left-Aligned PWM if you disregard the “initial-offset” or phase-shift. Here is what it looks like:

Since we are using Timer in PWM mode, calculations for Prescale and configuration is exactly the same. Essentially we have two 16-bit PWM blocks and two 32-bit PWM blocks. Each capable of generating 3 PWM outputs using first 3 match registers (MR0 to MR2). The last match register (MR3) is used to set the PWM Period. The Match outputs pins are used get the PWM output when PWM mode is enabled for the corresponding Match output. Please refer my previous timer tutorial for MAT pins.

Consider that our PWM Period duration is 5 milliseconds and TC increments every 1 millisecond using appropriate prescale value. We set MR3 to 5 i.e. 5 ticks of PWM TC. We have MR1 = 2 and MR2 = 4. We using T_OFF as Match values. Whenever the value in TC matches the value in any of the match register, its corresponding output it set to HIGH until the start of next PWM cycle as shown in PWM Timing Diagram below:

Registers used in LPC1114 PWM Programming

I have already explained TCR, PR, MRx & MCR registers in previous LPC1114 Tutorial, so I won’t explaining them in detail except for PWMC.

Configuring and Initializing PWM in LPC111x

Now lets see how to configure PWM. First we need to do some basic Calculations for defining the PWM Period time and the PWM Resolution using a prescale value. For this first we need to define the resolution of our PWM signal. PWM resolution is the minimum time delay that can used to increase or decrease the pulse width. More smaller the increment more fine will be the resolution. PWM Resolution is set using an appropriate Prescale Value.

Example :

//Select MATn.x Function Using appropriate IOCON register for PWM output
LPC_IOCON->..    = ... ; //Select MATx Function for pins being used
LPC_TMRnBx->PR   = ... ; //assign calculated PR value 
LPC_TMRnBx->MR3  = ... ; //Assign PWM Period Duration
LPC_TMRnBx->MRx  = ... ; //Assign Pulse off duration i.e. TOFF for other Match Regs
LPC_TMRnBx->MCR  = (1<<10); //Reset TC on MR3 match
LPC_TMRnBx->PWMC = ... ; //enable PWM mode for MATx pins as required
LPC_TMRnBx->TCR  = 0x2; //Reset PWM TC & PR

//Now , the final moment - enable TC
LPC_TMRnBx->TCR  = 0x1; //enable counters for PWM
//Done!

ARM Cortex-M0 LPC1114 PWM Examples with code

LPC1114 PWM Example 1 – LED Dimming

In this PWM Example we will use a Period of 1ms and vary the Duty-cycle from “almost” 0%(LED almost OFF) to 100%(Brightest). As mentioned earlier we cannot generate a duty-cycle of 0%(i.e. Signal Continuosly LOW), but it will close to 0%. Connect the LED anode to P1.18 and cathode to GND using a suitable resistor (like >330 Ohms). In the C++ code given below, I have also used 16Bit-Timer0 which is used by delayMS(..) function to generate delay before we update MR0 register with new value. Also note that we are using match values corresponding to T_OFF time. So we subtract T_ON from Period to get the match values which essentially makes the output a Phase-shifted PWM.

C++ Source code for Example 1:

/*(C) Umang Gajera - www.ocfreaks.com
More Embedded tutorials @ https://www.ocfreaks.com/cat/embedded/
LPC1114 PWM Tutorial Example 1 - LED Dimming using PWM.
License: GPL.*/
#include <lpc11xx.h>

#define PRESCALE_US (48-1) //Used by PWM
#define PRESCALE_MS (48000-1) //Used by 16Bit-TMR0 for generating delay
#define PWM_PERIOD 1000 //in micro-seconds

void init32BTMR0_PWM(void);
inline void updatePulseWidth(unsigned int pulseWidth);
void delayMS(unsigned int milliseconds);
void init16BTimer0(void);

int main (void)
{
	//SystemInit(); //called by Startup Code before main(), hence no need to call again.
	LPC_IOCON->PIO1_6 |= 0x2; //Select CT32B0_MAT0 (MAT0.0) function for PWM O/P, Marked as RXD on LPCXpresso Board

	int pulseWidths[] = {
			PWM_PERIOD-0,PWM_PERIOD-250,
			PWM_PERIOD-500,PWM_PERIOD-750,
			PWM_PERIOD-1000}; //Inverted Pulse Widths for varying LED Brightness
	//Note: PWM_PERIOD-0 = LED almost OFF, PWM_PERIOD-1000 = LED Brightest!
	//PWM Pulses in LPC1114 are Right-Aligned or "inverted"!
	const int numPulseWidths = 5;
	int count=1;
	int dir=0; //direction, 0 = Increasing, 1 = Decreasing

	init32BTMR0_PWM(); //Initialize 32Bit-TMR0 as PWM
	init16BTimer0(); //Used by delayMS()

	while(1)
	{
		updatePulseWidth(pulseWidths[count]); //Update LED Pulse Width
		delayMS(500);

		if(count == (numPulseWidths-1) || count == 0)
		{
			dir = !dir; //Toggle direction if we have reached count limit
		}

		if(dir) count--;
		else count++;
	}
  //return 0; //normally this won't execute ever
}

void init32BTMR0_PWM(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9); //Enable 32Bit-TMR0 Clock
	LPC_TMR32B0->CTCR = 0x0;
	LPC_TMR32B0->PR = PRESCALE_US; //Increment TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS
	LPC_TMR32B0->MR3 = PWM_PERIOD; //1ms Period duration
	LPC_TMR32B0->MR0 = PWM_PERIOD-250; //Default TOFF time in mS
	LPC_TMR32B0->MCR = (1<<10); //Reset on MR3 Match

	LPC_TMR32B0->PWMC = 0x1; //Enable PWM Mode for MAT0.0

	LPC_TMR32B0->TCR = 0x2; //Reset Timer
	LPC_TMR32B0->TCR = 0x1; //Enable timer
}

inline void updatePulseWidth(unsigned int pulseWidth)
{
	LPC_TMR32B0->MR0 = pulseWidth; //Update MR1 with new value
}

void delayMS(unsigned int milliseconds) //Using 16Bit-TMR0
{
	LPC_TMR16B0->TCR = 0x2; //Reset Timer
	LPC_TMR16B0->TCR = 0x1; //Enable timer

	while(LPC_TMR16B0->TC < milliseconds); //wait until timer counter reaches the desired delay

	LPC_TMR16B0->TCR = 0x0; //Disable timer
}

void init16BTimer0(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<7); //Enable 16Bit_Timer0 Clock
	LPC_TMR16B0->CTCR = 0x0;
	LPC_TMR16B0->PR = PRESCALE_MS; //Increment TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS
	LPC_TMR16B0->TCR = 0x2; //Reset Timer
}

LPC1114 PWM Example 2 – Basic RC Servo Control

In this Example we will sweep a servo from 1000us to 2000us pulse widths, back and forth in steps. The period is set to 20ms(20000us) which is common for servos. PWM1.1 output is selected and will be available on Pin P1.18. Warning: Double check all connections when connecting the motor or it will damage your board.

C++ Source Code for Example 2:

/*(C) Umang Gajera - www.ocfreaks.com
More Embedded tutorials @ https://www.ocfreaks.com/cat/embedded/
LPC1114 PWM Tutorial Example 2 - Simple Servo Control.
License: GPL.*/
#include <lpc11xx.h>

#define PRESCALE_US (48-1) //Used by PWM
#define PRESCALE_MS (48000-1) //Used by 16Bit-TMR0 for generating delay
#define PWM_PERIOD 20000 //in micro-seconds

void init32BTMR0_PWM(void);
inline void updatePulseWidth(unsigned int pulseWidth);
void delayMS(unsigned int milliseconds);
void init16BTMR0(void);

int main (void)
{
	//SystemInit(); //called by Startup Code before main(), hence no need to call again.
	LPC_IOCON->PIO1_6 |= 0x2; //Select CT32B0_MAT0 (MAT0.0) function for PWM O/P, Marked as RXD on LPCXpresso Board

	int pulseWidths[] = {
			PWM_PERIOD-1000,PWM_PERIOD-1250,
			PWM_PERIOD-1500,PWM_PERIOD-1750,
			PWM_PERIOD-2000}; //Inverted Pulse Widths
	//Note: PWM_PERIOD-1000 will generate a Right aligned Pulse of 1000us and so on..
	//PWM Pulses in LPC1114 are Right-Aligned or "inverted"!
	const int numPulseWidths = 5;
	int count=1;
	int dir=0; //direction, 0 = Increasing, 1 = Decreasing

	init32BTMR0_PWM(); //Initialize 32Bit-TMR0 as PWM
	init16BTMR0(); //Used by delayMS()

	while(1)
	{
		updatePulseWidth(pulseWidths[count]); //Update LED Pulse Width
		delayMS(1000);

		if(count == (numPulseWidths-1) || count == 0)
		{
			dir = !dir; //Toggle direction if we have reached count limit
		}

		if(dir) count--;
		else count++;
	}
  //return 0; //normally this won't execute ever
}

void init32BTMR0_PWM(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9); //Enable 32Bit-TMR0 Clock
	LPC_TMR32B0->CTCR = 0x0;
	LPC_TMR32B0->PR = PRESCALE_US; //Increment TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS
	LPC_TMR32B0->MR3 = PWM_PERIOD; //20ms Period duration
	LPC_TMR32B0->MR0 = PWM_PERIOD-1250; //Default TOFF time in mS
	LPC_TMR32B0->MCR = (1<<10); //Reset on MR3 Match

	LPC_TMR32B0->PWMC = 0x1; //Enable PWM Mode for MAT0.0

	LPC_TMR32B0->TCR = 0x2; //Reset Timer
	LPC_TMR32B0->TCR = 0x1; //Enable timer
}

inline void updatePulseWidth(unsigned int pulseWidth)
{
	LPC_TMR32B0->MR0 = pulseWidth; //Update MR1 with new value
}

void delayMS(unsigned int milliseconds) //Using 16B-TMR0
{
	LPC_TMR16B0->TCR = 0x2; //Reset Timer
	LPC_TMR16B0->TCR = 0x1; //Enable timer

	while(LPC_TMR16B0->TC < milliseconds); //wait until timer counter reaches the desired delay

	LPC_TMR16B0->TCR = 0x0; //Disable timer
}

void init16BTMR0(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<7); //Enable 16Bit-TMR0 Clock
	LPC_TMR16B0->CTCR = 0x0;
	LPC_TMR16B0->PR = PRESCALE_MS; //Increment TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS
	LPC_TMR16B0->TCR = 0x2; //Reset Timer
}

The post LPC1114 PWM Programming Tutorial appeared first on OCFreaks!.

This time we will go through ARM Cortex-M0 LPC1114 Timer Tutorial. In a previous LPC1114 tutorial we did a blinky example using GPIO and harcoded delays, now its time to improvise and use precise delay using timers. LPC111x MCUs have two 16-bit Timers and two 32-bit Timers. Both of them are similar in operation except for the bit size. We will be using 32-bit timers in this tutorial. Each Timer block can be used as a ‘Timer’ (e.g. triggering an interrupt every ‘t’ microseconds) or as a ‘Counter’ and can be also used to demodulate PWM signals given as input, find frequency of external signal, etc.

Introduction

Each Timer module has its own Timer Counter(TC) and Prescale Register(PR) associated with it. When a Timer is Reset and Enabled, the TC is set to 0 and incremented by 1 every ‘PR+1’ clock cycles – where PR is the value stored in Prescale Register. When it reaches its maximum value it gets reset to 0 and hence restarts counting. Prescale Register is used to define the resolution of the timer. If PR is 0 then TC is incremented every 1 clock cycle of the peripheral clock. If PR=1 then TC is incremented every 2 clock cycles of peripheral clock and so on. By setting an appropriate value in PR we can make timer increment or count: every peripheral clock cycle or 1 microsecond or 1 millisecond or 1 second and so on.

LPC1114/302 (LPC1100L Series) which is found on LPCXpresso Board has four Match Outputs and one Capture Input.

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 tutorial.

Match Registers can be used to:

• Stop Timer on Match(i.e when the value in count register is same as than in Match register) and trigger an optional interrupt.
• Reset Timer on Match and trigger an optional interrupt.
• To count continuously and trigger an interrupt on match.

External Match Output

When a corresponding Match register(MRx) equals the Timer Counter(TC) the match output can be controlled using External Match Register(EMR) to : either toggle, go HIGH, go LOW or do nothing.

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. We are not going to use them in this tutorial since we are only concerned with using Timer block as a ‘Timer’. We’ll see them in a later tutorial.

Registers used in LPC111x Timer Programming

We will be using CMSIS based lpc11xx.h header file for programming. In CMSIS, all the Registers used to program and use 32-bit timers are defined as members of structure(pointer) LPC_TMR32Bx where x is the 32-bit Timer module 0 or 1. So for Timer0 we will use LPC_TMR32B0 and so on. Registers can be accessed by de-referecing the pointer using “->” operator. For, example we can access TCR of Timer0 block as LPC_TMR32B0->TCR. Similary for 16-bit Timer block, the structure is defined as LPC_TMR16Bx where x is the 16-bit Timer module 0 or 1. Now lets see some of the main 32-bit timer registers.

Configuring Timers in LPC1114

To use timers we need to first configure & initialize them. We need to set appropriate values in CTCR, IR, PR registers and reset PC, TC registers. Finally we assign TCR = 0x01 which enables the timer.

Selecting Match Outputs: Match outputs for Timer0(CT32B0) and Timer1(CT32B1) is available as an alternate function on pins given below. Match output function must be selected using IOCON registers for the following pins:

• Timer0 MAT 0 (CT32B0_MAT0) – PIO1_6
• Timer0 MAT 1 (CT32B0_MAT1) – PIO1_7
• Timer0 MAT 2 (CT32B0_MAT2) – PIO0_1
• Timer0 MAT 3 (CT32B0_MAT3) – PIO2_8
• Timer1 MAT 0 (CT32B1_MAT0) – PIO1_1
• Timer1 MAT 1 (CT32B1_MAT1) – PIO1_2
• Timer1 MAT 2 (CT32B1_MAT2) – PIO1_3
• Timer1 MAT 3 (CT32B1_MAT3) – PIO1_4

You can go through my previous tutorial on IOCON register regarding its usage.

Enabling System AHB Clock for Timer: The input clock for timers is from System AHB clock or simply the System Clock. The System Clock can be derived from the Main Clock using System AHB Clock Divider Register SYSAHBLKDIV. System Clock for Peripherals like Timers needs to be enabled, before using them, by setting appropriate bits (1=enable, 0=disable) in System AHB Clock Control Register SYSAHBCLKCTRL as given below:

• Bit 7 For 16-Bit Timer0 (CT16B0)
• Bit 8 For 16-Bit Timer1 (CT16B1)
• Bit 9 For 32-Bit Timer0 (CT32B0)
• Bit 10 For 32-Bit Timer1 (CT32B1)

Now lets implement to basic function required for Timer Operation:
1. void initTimer0(void);
2. void delayMS(unsigned int milliseconds);

#1) initTimer0(void); [Used in Example #1]

#define PRESCALE (48000-1)

void initTimer0(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/

	LPC_TMR32B0->CTCR = 0x0;
	LPC_TMR32B0->PR = PRESCALE; //Increment TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS

	LPC_TMR32B0->TCR = 0x02; //Reset Timer
}

#2) delayMS(unsigned int milliseconds); – LPC1114 Timer Delay Function

void delayMS(unsigned int milliseconds) //Using Timer0
{
	LPC_TMR32B0->TCR = 0x02; //Reset Timer

	LPC_TMR32B0->TCR = 0x01; //Enable timer

	while(LPC_TMR32B0->TC < milliseconds); //wait until timer counter reaches the desired delay

	LPC_TMR32B0->TCR = 0x00; //Disable timer
}

Real World LPC1114 Timer Examples with sample code

Example 1) – LPC111x Blinky Example using Timer & GPIO

Now lets write a C/C++ blinky program which flashes an LED every half a second. Since 0.5 second = 500 millisecond we will invoke timer delay function ‘delayMS’ as delayMS(500). The LED is connected to Pin PIO0_7.

/*(C) Umang Gajera - www.ocfreaks.com 2011-17.
More Embedded tutorials @ www.ocfreaks.com/cat/embedded/
LPC1114 Basic Timer example. License: GPL.*/

#include <lpc11xx.h>

#define PRESCALE (48000-1) //48000 PCLK clock cycles to increment TC by 1 

void delayMS(unsigned int milliseconds);
void initTimer0(void);

int main(void)
{
	//SystemInit(); //called by Startup Code before main(), hence no need to call again.
	initTimer0(); //Initialize Timer0
	LPC_GPIO0->DIR = (1<<7); //Configure PIO0_7 as output

	while(1)
	{
		LPC_GPIO0->DATA = (1<<7); //Turn LED ON
		delayMS(500); //0.5 Second(s) Delay
		LPC_GPIO0->DATA = ~(1<<7); //Turn OFF LED
		delayMS(500);
	}
	//return 0; //normally this wont execute ever
}

void initTimer0(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9); //Enable 32Bit Timer0 Clock
	LPC_TMR32B0->CTCR = 0x0;
	LPC_TMR32B0->PR = PRESCALE; //Increment LPC_TMR32B0->TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS
	LPC_TMR32B0->TCR = 0x02; //Reset Timer
}

void delayMS(unsigned int milliseconds) //Using Timer0
{
	LPC_TMR32B0->TCR = 0x02; //Reset Timer
	LPC_TMR32B0->TCR = 0x01; //Enable timer

	while(LPC_TMR32B0->TC < milliseconds); //wait until timer counter reaches the desired delay

	LPC_TMR32B0->TCR = 0x00; //Disable timer
}

Example 2) – LPC111x example code using Timer & Match Outputs

In this C/C++ Example we will use Match outputs 0 and 1 of 32-bit Timer 0 i.e. CT32B0_MAT0 and CT32B0_MAT1. CT32B0_MAT0 is pinned to PIO1_6(P1.6) and CT32B0_MAT1 pinned to PIO1_7(P1.7). You can connect LED to any of the Match ouput pin (PIO1_6 or PIO1_7) and see the code in action. Note that, on LPCXpresso 1114 Board PIO1_6 is marked as RXD and PIO1_7 is marked as TXD since these pin have UART alternate functions.

/*(C) Umang Gajera - https://www.ocfreaks.com 2011-17.
More Embedded tutorials @ https://www.ocfreaks.com/cat/embedded/
LPC1114 Timer example 2. License: GPL.*/

#include <lpc11xx.h>

#define PRESCALE (48000-1) //48000 PCLK clock cycles to increment TC by 1 

void initTimer0(void);

int main (void)
{
	//SystemInit(); //called by Startup Code before main(), hence no need to call again.

	LPC_IOCON->PIO1_6 |= 0x2; //Select CT32B0_MAT0 function - Marked as TXD on LPCXpresso Board
	LPC_IOCON->PIO1_7 |= 0x2; //Select CT32B0_MAT1 function - Marked as RXD on LPCXpresso Board

	initTimer0(); //Initialize Timer0

	while(1)
	{
		//Idle loop
	}
	//return 0; //normally this won't execute
}

void initTimer0(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9); //Enable 32Bit Timer0 Clock
	LPC_TMR32B0->CTCR = 0x0;
	LPC_TMR32B0->PR = PRESCALE; //Increment LPC_TMR32B0->TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS

	LPC_TMR32B0->MR0 = 500; //toggle time in mS
	LPC_TMR32B0->MCR = (1<<1); //Reset on MR0 Match
	LPC_TMR32B0->EMR |= (1<<7) | (1<<6) | (1<<5) | (1<<4); //Toggle Match output for MAT0.0(P2.5), MAT0.1(P2.6)

	LPC_TMR32B0->TCR = 0x02; //Reset Timer
	LPC_TMR32B0->TCR = 0x01; //Enable timer
}

Example 3) – LPC1114 Timer Interrupt Example Code

Here we will use a timer interrupt function which will be called periodically to blink an LED. The Timer Interrupt Service Routine (ISR) will toggle PIO0_7(P0.7) every time it is called. If you are using C++ file then you will need to add extern “C” before the ISR definition or C++ linker won’t be able to link it properly to generate finally binary/hex file. For C code this is not required.

/*(C) Umang Gajera - https://www.ocfreaks.com
More Embedded tutorials @ https://www.ocfreaks.com/cat/embedded/
LPC1114 Timer example 3. License: GPL.*/

#include <lpc11xx.h>

#define PRESCALE (48000-1) //48000 PCLK clock cycles to increment TC by 1 

void initTimer0();

int main(void)
{
	//SystemInit(); //called by Startup Code before main(), hence no need to call again.
	LPC_GPIO0->DIR |= (1<<7); //set PIO0_7 as output
	initTimer0();

	while(1)
	{
		//Idle loop
	}
	//return 0; //normally this won't execute
}

void initTimer0(void)
{
	/*Assuming CCLK (System Clock) = 48Mhz (set by startup code)*/
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9); //Enable 32Bit Timer0 Clock

	LPC_TMR32B0->CTCR = 0x0;
	LPC_TMR32B0->PR = PRESCALE; //Increment LPC_TMR32B0->TC at every 47999+1 clock cycles
	//48000 clock cycles @48Mhz = 1 mS

	LPC_TMR32B0->MR0 = 500; //Toggle Time in mS
	LPC_TMR32B0->MCR |= (1<<0) | (1<<1); // Interrupt & Reset on MR0 match
	LPC_TMR32B0->TCR |= (1<<1); //Reset Timer0

	NVIC_EnableIRQ(TIMER_32_0_IRQn); //Enable timer interrupt

	LPC_TMR32B0->TCR = 0x01; //Enable timer
}

extern "C" void TIMER32_0_IRQHandler(void) //Use extern "C" so C++ can link it properly, for C it is not required
{
	LPC_TMR32B0->IR |= (1<<0); //Clear MR0 Interrupt flag
	LPC_GPIO0->DATA ^= (1<<7); //Toggle LED
}

The post LPC1114 Timer Programming Tutorial appeared first on OCFreaks!.

Most of the function pins on LPC1114, LPC1115, LPC11C14 Micro-controllers are grouped into Ports. LPC1114 has maximum of 4 ports viz. Port 0 to 3. For some LPC1100 devices ports 2 & 3 may be disabled; and even if enabled some pins may be disabled/reserved. The GPIO block in LPC11xx devices is connected to Peripheral AHB-Lite bus (Advanced High performance Bus – Lite) for fast read/write timing. By default, all pins are configured as inputs after reset.

The registers for each port are grouped into a structure with the following naming convention: LPC_GPIOx , where x is the port number. The GPIO ports are 12-bit wide i.e. a maximum 12 pins can be mapped, but each port may some pins which cannot be used i.e. they are ‘reserved’. Since the ports are only 12 bits wide, half-word(16 bit) values can be used to assign GPIO registers. For this tutorial I will be using LPC1114F/302 in LQFP48 package as reference. For other packages like TSSOP28, QFN33, etc. please refer table no. 172 on page 191 of the manual (Rev 12.4) for which pins are available.

For LPC1114 (LQFP48):

• All 12 pins on Ports 0, 1 and 2 are available.
• On Port 3 only first 6 pins (i.e. PIO3_0 to PIO3_5) are available. Rest are reserved.

GPIO Registers in LPC111x

The GPIO block has many registers. We will only go through some of these registers that are within the scope of this tutorial.

IOCON (I/O Configuration) Registers – Each pin has a dedicated IOCON register with which we can control: the function of PIN, enable pull-up or pull-down, Hysteresis to filter out spurious changes in input, and other modes like I2C, ADC and Open-Drain. For using digital GPIO we are only concerned with : Changing Pin function , enabling internal pull-up/down resistors and hysteresis. In CMSIS, all the IOCON registers are grouped under LPC_IOCON structure. While programming these can be accessed as LPC_IOCON->[register-name]. Where [register-name] is the name of the IOCON register for a specific PIN as given in datasheet/manual.

The general bit description for IOCON register is as shown in the diagram below:

• First 2 bits [2:0] are used for selecting PIN function: 0x0 – 1st function, 0x1 – 2nd function, 0x2 – 3rd function, 0x3 – 4th function. Refer datasheet for which functions are available for the given PIN.
• Next 2 bits [3:4] are used to select on-chip pull resistors: 0x0 – Both pull-up/down resistors disabled, 0x1 – Pull-down resistor enabled, 0x2 – Pull-up resistor enabled, 0x3 – Repeater mode.
• 5th Bit [5] is for Hysteresis. Setting it to 0 will disable Hysteresis and 1 will enable it.

I have discussed IOCON register in detail for LPC1114 in my previous tutorial : LPC11xx and LPC13xx LPC_IOCON Register Tutorial

Most of the PINS of LPC11xx MCU are Multiplexed i.e. these pins can be configured to provide up to 4 alternate functions. Not all pins on LPC111x are configured as GPIO by default after reset! For these pins you will need to explicitly re-assign the function to GPIO using IOCON register for the respective pins. Other pins can be directly used as GPIO, since their default function is GPIO (configured as inputs with pull-ups enabled) after reset.

LPC111x GPIO Programming & Example Code in C/C++

LPC11xx.h header is based on CMSIS(Cortex Microcontroller System Interface Standard) developed by ARM. System startup, core CPU access and peripheral definitions are given by CMSIS-CORE component of CMSIS. We will be using the definitions given by CMSIS-CORE. The register definitions for Cortex-M0 LPC111x MCUs are organized into groups depending on their functionality using “C Structure” definitions. From C/C++ programming point of view, this makes interfacing peripherals simple. For example all registers for Port 0 are grouped into structure defined as LPC_GPIO0. This is similar when programming for any LPC ARM Cortex-M0 MCU using CMSIS.

As per the CMSIS convention, the registers that we saw are grouped into structures. LPC_GPIOx is defined as a pointer to this structure in LPC11xx.h header. These registers are defined as members of this structure. Hence to use any register, for e.g. DATA, we must use the arrow “->” operator to de-reference members of structure (since the structure itself is a pointer) to access the register as follows : LPC_GPIO0->DATA = value. For creating LPC1114 projects you can either use KEIL uV5, LPCXpresso or MCUXpresso, but make sure you include CMSIS library. If you are using LPCXpresso LPC1114 board you can check out this tutorial.

Prerequisite : Before we start programming gpio you need to have basic understanding of Binary and Hexadecimal system and Bitwise operations in C/C++, here are two tutorials which can go through (or if you are already acquainted with these you can skip these and continue below) :

• Hexadecimal and Binary Number System basics for Embedded Programming
• Tutorial : Embedded programming basics in C – bitwise operations

Now lets see how we can assign values to registers. We can use Hexadecimal notation & decimal notation for assigning values. If your compiler supports other notations like binary notation use can use that too. Lets say, we want to set PIN 5 of Port 0 as output. It can be done in following ways:

CASE 1. LPC_GPIO0->DIR = (1<<5); //(binary using left shift - direct assign: other pins set to 0)

CASE 2. LPC_GPIO0->DIR |= 0x0000020; //or 0x20; (hexadecimal - OR and assign: other pins not affected)

CASE 3. LPC_GPIO0->DIR |= (1<<5); //(binary using left shift - OR and assign: other pins not affected)

• In many scenarios, Case 1 must be avoided since we are directly assigning a value to the register. So while we are making PIO0_5 ‘1’ others are forced to be assigned a ‘0’ which can be avoided by ORing and then assigning Value.
• Case 2 can be used when bits need to be changed in bulk and
• Case 3 when some or single bit needs to be changed.

First thing to note here is that preceding Zeros in Hexadecimal Notation can be ignored because they have no meaning since we are working with unsigned values here (positive only) which are assigned to Registers. For eg. 0x1C and 0x01C and 0x001C all mean the same.

Now, Lets go through some example codes:

Ex. 1)

Consider that we want to configure Pin 1 of Port 0 i.e PIO0_1(P0.1) as Output and want to drive it HIGH. This can be done as :

LPC_GPIO0->DIR |= 0x2; //same as (1<<1), Config PIO0_1 as Ouput
LPC_GPIO0->DATA |= 0x2; //Drive Output High for PIO0_1

Ex. 2)

Making output configured Pin 7 High of Port 0 i.e PIO0_7(P0.7) and then Low can be does as follows:

LPC_GPIO0->DIR |= (1<<7); //PIO0_7 is Output pin
LPC_GPIO0->DATA |= (1<<7); //Output for PIO0_7 becomes High
LPC_GPIO0->DATA &= ~(1<<7); //Output for PIO0_7 becomes Low

Ex. 3)

Configuring PIO0_9(P0.9) and PIO0_3(P0.3) as Output and Setting them High:

LPC_GPIO0->DIR |= (1<<9) | (1<<3); //Config PIO0_9 and PIO0_3 as Output
LPC_GPIO0->DATA |= (1<<9) | (1<<3); //Drive Output High for PIO0_9 and PIO0_3

Ex. 4)

Configuring Pins 4 to 11 of Port 1 (PIO1_4 to PIO1_11) as Output and Setting them High:

LPC_GPIO1->DIR |= 0xFF0; //Config PIO1_4 to PIO1_11 as Output
LPC_GPIO1->DATA |= 0xFF0; //Make output High for PIO1_4 to PIO1_11

Ex. 5)

In this example code, we will configure Pin 5 of Port 1 as Input with Pull-Down & Hysteresis enabled :

LPC_GPIO1->DIR &= ~(1<<5); //Config PIO1_5 as input (It will be anyways input after reset)
LPC_IOCON->PIO1_5 = (1<<3) | (1<<5); 
//Enable on-chip Pull-down resistor [4,3]=01, Enable HYS [5]=1

When using switches as inputs, you can use an RC filter with Hysteresis enabled to debounce the input. Bouncing is the spurious changes in input until the contacts of the switch have stabilized. This can be filtered out using debouncing techniques, either in Software or Hardware.

Now lets play with some real world examples.

Ex. 6)

LPC11xx Blinky Example Code - Here we drive pin 7 of port 0 (PIO0_7) repeatedly high to low. PIO0_7(P0.7) of LPC11xx devices has 20mA current capability so you can directly drive an LED with it. Connect LED between PIO0_7 and GND. Here we will introduce some "hard-coded" delay between making all pins High and Low (and vice-versa) so it can be noticed.

#include <lpc11xx.h>

void delay(void);

int main(void)
{
	LPC_GPIO0->DIR = (1<<7); //Configure PIO0_7 as Output
	
	while(1)
	{
		LPC_GPIO0->DATA = (1<<7); //Drive output high to turn on LED
		// Better way would be LPC_GPIO0->DATA |= (1<<7);
		
		delay();
		LPC_GPIO0->DATA = 0x0; //Drive output low to turn off LED
		// Better way would be LPC_GPIO0->DATA &= ~(1<<7);
		
		delay();
	}
	return 0; //normally this wont execute
}	

void delay(void) //Hard-coded delay function
{
	int count,i=0;
	for(count=0; count < 3000000; count++) //You can edit this as per your needs
	{
		i++; //something needs to be here else compiler will remove the for loop!
	}
}

Ex. 7)

In this example we will configure PIO1_5(P1.5) as Input and monitor it for a logic LOW on the pin. Here we will use a tactile switch whose one end is connected to PIO1_5 and other to GND (+3.3V). PIO0_7(P0.7) is configured as output and connected to an LED. Initially LED will be off but when the switch is pressed, LED will be turned ON. Once the LED is turned ON it will stay ON until the MCU is reset externally. The setup is shown in the figure below:

#include <lpc11xx.h>

int main(void)
{
	LPC_GPIO1->DIR &= ~((1<<5)) ; //explicitly making PIO1_5 as Input - even though by default its already Input
	LPC_GPIO0->DIR |= (1<<7); //Configuring PIO0_7 as Output

	LPC_GPIO0->DATA &= ~(1<<7); //drive output low initially

	while(1)
	{
		if( LPC_GPIO1->DATA & (1<<5) ) //Evaluates to True for a 'HIGH' on PIO1_5
		{
			LPC_GPIO0->DATA |= (1<<7); //drive PIO0_7 High
			//Now PIO0_7 will be held high unless the MCU is reset
		}
	}
	return 0; //this wont execute normally
}

Ex. 8)

Now lets extend example 7 so that when the button is pressed, the LED will glow and when released or not pressed the LED won't glow. Note that in both Example 7 and 8: Since internal pulls are enabled by default when switch is not pressed, internal pull-up resistor will force the input to be HIGH.

#include <lpc11xx.h>

void tinyDelay(void);

int main(void)
{
	LPC_GPIO1->DIR &= ~((1<<5)); 
	LPC_GPIO0->DIR |= (1<<7);
	
	LPC_GPIO0->DATA &= ~(1<<7); //Turn off LED initially
	
	while(1)
	{
		if( !(LPC_GPIO1->DATA & (1<<5)) )
		{
			LPC_GPIO0->DATA |= (1<<7); //Input low, so turn led ON
		}
		else
		{
			LPC_GPIO0->DATA &= ~(1<<7); //Input high, so turn led OFF
		}
	}
	
	return 0; //normally this won't execute
}

The post LPC1114 GPIO Programming Tutorial appeared first on OCFreaks!.

Each pin on MCUs like LPC1114, LPC1115, LPC1343, LPC1347, etc.. have a dedicated IOCON register with which we can control:

• the Function (for e.g. GPIO or any other Function like TXD,I2C,etc..)
• the Input Mode i.e. pull-up, pull-down, repeater mode or none
• Hysteresis which gives schmitt trigger action to filter out spurious changes on inputs
• I2C bus modes for I2C bus pins
• selection of analog input mode for ADC pins
• selection of open-drain mode for output, if available

You can check the User-Manual or Datasheet of your LPC Cortex-M Micro-controller to check which of the above are available.

General Bit Description of IOCON registers for LPC1114 and LPC1343 is as given below:

For pins hosting ADC function the IOCON structure is as follows:

For pins hosting I2C function IOCON bit Mapping is as given below:

Note: pseudo open-drain mode is Not available for LPC1343/42/13/12 devices.

IOCON register for other LPC13x7 devices

For devices like LPC1347 ICOCON register given additional control like:

• Logic Inversion of input pins, if available
• Input Glitch filter, on pins which support it, if available

The general register map for similar devices is as given below:

The different in structure is that:

• Bit 6 now represents INV which is used to invert the Input(HIGH is read LOW and vice-versa) by setting this bit to 1. If the bit is 0 inputs are not inverted.
• For a few pins Bit 8 represents FILTR which is used to enabled/disable glitch filter. 0 means glitch filter is enabled and 1 means its disabled.

Using IOCON registers in programming

In the device header files based on CMSIS viz. lpc11xx.h and lpc13xx.h all the IOCON registers are grouped under LPC_IOCON structure. While programming in C/C++ , these can be accessed as: LPC_IOCON->[register-name]. Where [register-name] is the name of the IOCON register for a specific PIN as given in datasheet/manual.

For example, to access IOCON for PIO0_1(P0.1) in your code you must use LPC_IOCON->PIO0_1 = value.

Eg.:

/*LPC11xx*/
LPC_IOCON->RESET_PIO0_0
LPC_IOCON->PIO0_8
LPC_IOCON->R_PIO0_11
...

/*LPC13xx*/
LPC_IOCON->PIO0_1
LPC_IOCON->SWDIOCLK_PIO0_10
LPC_IOCON->R_PIO1_10
...

The post LPC1114 and LPC1343 LPC_IOCON Register Tutorial appeared first on OCFreaks!.