LPC134x ADC Block

Analog to Digital Conversion is used when want to interface an external analog signal or when interfacing analog sensors, like for example a temperature sensor. The ADC block in ARM Cortex-M3 LPC1343 Microcontroller is based on Successive Approximation(SAR) conversion method. LPC1343 ADC Module uses 10-bit SAR having a conversion time of >= 2.44us i.e. around 409Khz max convertion rate. The Measurement range is from 0V to V_DD, or commonly from 0V to ~3.3V (3.6V max). Maximum of 8 multiplexed inputs can be used for ADC.

Pins relating to ADC Module:

LPC134x ADC Registers

Lets see registers which are used for ADC programming.

ADC Modes, Setup and Programming

ADC modes in LPC1343:

1. Software controlled mode : In Software mode only one conversion will be done at a time. To perform another conversion you will need to restart the process. In software mode, only 1 bit in the SEL field of ADCR can be 1 i.e. only 1 Channel(i.e. Pin) can be selected for conversion at a time. Hence conversions can be done only any channel but one at a time.
2. Hardware or Burst mode : In Hardware or Burst mode, conversions are performed continuously on the selected channels in round-robin fashion. Since the conversions cannot be controlled by software, Overrun may occur in this mode. Overrun is the case when a previous conversion result is replaced by new conversion result without previous result being read i.e. the conversion is lost. Usually an interrupt is used in Burst mode to get the latest conversion results. This interrupt is triggered when conversion in one of the selected channel ends.

1A. Setting up and configuring ADC Module for software controlled mode

First, lets define some values which will help us in setting up ADCR register to configure & Initialize ADC block.

#define ADC_CLK_EN (1<<13) //Enable ADC clock

#define SEL_AD0    (1<<0) //Select Channel AD0

#define CLKDIV     15 // ADC clock-divider (ADC_CLOCK=PCLK/CLKDIV+1), yields 4.5Mhz ADC clock  
 
#define ADC_PWRUP  (~(1<<4)) //setting it to 0 will power it up 
 
#define START_CNV  (1<<24) //001 for starting the conversion immediately
 
#define ADC_DONE   (1U<<31) //define it as unsigned value or compiler will throw #61-D warning

#define ADCR_SETUP_SCM (CLKDIV<<8)
//SCM = Software Controlled Mode

Now we assign ADCR_SETUP to ADCR along with channel selection information to select channels as required. Finally we assign(by ORing) START_NOW to ADCR to start the conversion process as shown:

LPC_SYSCON->PDRUNCFG &= ADC_PWRUP; //Power-up ADC Block
LPC_SYSCON->SYSAHBCLKCTRL |= ADC_CLK_EN; //Enable ADC clock
LPC_ADC->CR = ADCR_SETUP_SCM | SEL_AD0; //Setup ADC Block
LPC_ADC->CR |= START_CNV; //Start Conversion immediately

Note that before setting ADC using ADCR the ADC block must be powered-up using PDRUNCFG register and ADC Clock must be enabled using SYSAHBCLKCTRL register.

1B. Fetching the conversion result in software controlled mode :

In software controlled mode we continuously monitor bit 31 in the corresponding channel data register ADDR. If bit 31 changes to 1 from 0, it means that current conversion has been completed and the result is ready. For example, if we are using channel 0 of AD0 then we monitor for changes in bit 31 as follows :

while((LPC_ADC->DR0 & ADC_DONE) == 0); //this loop will end when bit 31 of AD0DR6 changes to 1.

After this we extract the result which is stored in ADDR bits 4 to 15. Here we right shift ADDR by 6 places and force all other unrelated bits to 0 by using a 10-bit mask value of 0x3FF. 0x3FF is a mask containing 1's in bit locations 0 to 9 and rest 0's. In our case with ADDR0 being used, it can be done as follows :

result = (LPC_ADC->DR0>>6) & 0x3FF;

2A. Setting up and configuring ADC Module for Burst mode

Configuring ADC Module is similar to what was done in software controlled mode except here we use the CLKS bits and don't use the START bits in ADCR. ADC_DONE is also not applicable since we are using an ISR which gets triggered when a conversion completes on any of the enabled channels. Additionally, we define the following constants:

 
#define BURST_ON  (1<<16) // 1 for on and 0 for off

#define ADCR_SETUP_BURST ((CLKDIV<<8) | BURST_ON)

We configure and setup the ADC module in a similar manner(as shown above) as follows :

LPC_SYSCON->PDRUNCFG &= ADC_PWRUP; //Power-up ADC Block
LPC_SYSCON->SYSAHBCLKCTRL |= ADC_CLK_EN; //Enable ADC clock
LPC_ADC->CR =  ADCR_SETUP_BURST | SEL_AD0; //Setup ADC Block

Note that in this case we can select multiple channels for conversion when setting up AD0CR. START bits are not applicable here since the conversions starts as soon we setup AD0CR register.

2B. Fetching the conversion result in Burst mode :

In Burst mode we use an ISR which triggers at the completion of a conversion in any one of the channel. Now, we just need to find the Channel for which the conversion was done. For this we fetch the channel number from ADGDR which also stores the conversion result. Bits [26:24] in ADGDR contain the channel number. Hence, we shift it 24 places and use a 3-bit mask value of 0x7 as shown below:

unsigned long AD_GDR_Read = LPC_ADC->GDR;
int channel = (AD_GDR_Read>>24) & 0x7; //Extract Channel Number

After knowing the Channel number, we have 2 options to fetch the conversion result from. Either we can fetch it from ADGDR or from ADDRx of the corresponding channel. Lets use ADGDR for extracting the conversion result as follows:

int currentResult = (AD_GDR_Read>>6) & 0x3FF; //Extract Conversion Result

ARM Cortex-M3 LPC1343 ADC Example

Note that in this case no input protection nor filtering was required. But, when Interfacing external analog signals it is recommended to use some form of input protection.

Interfacing Potentiometer using ADC on LPC134x

This example performs Analog to Digital conversion in Software Controlled Mode. Here we use PIO0_11(P0.11) as analog input for measuring the voltage. PIO0_11 corresponds to Channel 0 of ADC i.e. AD0. For testing I had used a 10K potentiometer for ADC Interfacing and connected the middle leg of POT to PIO0_11 of my LPC1343 development board. You can also use a 5K potentiometer for this ADC Example. PIO0_11 is marked as AD0 on LPCXpresso board. Schematic for this example is as shown below:

Source Code :

/*(C) Umang Gajera - www.ocfreaks.com
LPC1343 ADC Interfacing Example 1 Source Code for MCUXpresso
More Embedded tutorials @ www.ocfreaks.com/cat/embedded/
License : GPL.*/

#include <lpc17xx.h>
#include <stdio.h>
#include "ocf_LPC134x_lib.h" //contains code for UART, Timer & to retarget printf().

#define VREF       3.3 //Reference Voltage at VREFP pin, given VREFN = 0V(GND)
#define ADC_CLK_EN (1<<13) //Enable ADC clock
#define SEL_AD0    (1<<0) //Select Channel AD0
#define CLKDIV     15 // ADC clock-divider (ADC_CLOCK=PCLK/CLKDIV+1), yields 4.5Mhz ADC clock
#define ADC_PWRUP  (~(1<<4)) //setting it to 0 will power it up
#define START_CNV  (1<<24) //001 for starting the conversion immediately
#define ADC_DONE   (1U<<31) //define it as unsigned value or compiler will throw warning
#define ADCR_SETUP_SCM (CLKDIV<<8)

int main(void)
{
	//SystemInit(); //Gets called by Startup code, sets CCLK=100Mhz, PCLK=25Mhz
	initUART(); //Initialize UART for printf()
	initTimer0(); //For delayMS()

	LPC_SYSCON->PDRUNCFG &= ADC_PWRUP; //Power-up ADC Block
	LPC_SYSCON->SYSAHBCLKCTRL |= ADC_CLK_EN; //Enable ADC clock
	LPC_ADC->CR =  ADCR_SETUP_SCM | SEL_AD0; //Setup ADC Block

	/* Now select AD0 function and set ADMODE=0 for PIO0_11(P0.11) */
	LPC_IOCON->R_PIO0_11 = 0x2; //Use this for KEIL and LPCXpresso/MCUXpresso - check tutorial for more
	//LPC_IOCON->JTAG_TDI_PIO0_11 = 0x2; //Older version of CMSIS uses this. Uncomment this for CoIDE.

	unsigned int result = 0;
	float voltage = 0;

	printf("OCFreaks.com LPC134x ADC Tutorial Example 1.\nSoftware Controlled ADC Mode on AD0 Channel.\n");
	while(1)
	{
		LPC_ADC->CR |= START_CNV; //Start new Conversion
		while((LPC_ADC->DR0 & ADC_DONE) == 0); //Wait until conversion is finished
		
		result = (LPC_ADC->DR0>>6) & 0x3FF; //10 bit Mask to extract result
		voltage = ((float)result * VREF) / 1024;
		
		printf("AD0 = %dmV\n" , (int)(voltage*1000)); //Print millivolts
		delayMS(500); //Slowing down Updates to 2 Updates per second
	}

	//return 0; //This won't execute
}

LPC1343 ADC Interrupt Example

Now, lets cover an example using Hardware controlled mode or Burst mode using ADC Interrupt. In this mode we will have to use ADC interrupt since the ADC block will scan the selected channels and generated interrupt when a conversion gets finished on a particular channel. It scans the channels in round-robin fashion.

In this example too, we will use PIO0_11(P0.11) for measuring the voltage. The connections are same as given in example 1. The ADC ISR ADC_IRQHandler() gets called everytime conversion is finished on selected channel.

Source Code:

/*(C) Umang Gajera - www.ocfreaks.com
LPC1343 ADC Interrupt Example Source Code for MCUXpresso
More Embedded tutorials @ www.ocfreaks.com/cat/embedded/
License : GPL.*/

#include <lpc17xx.h>
#include <stdio.h>
#include "ocf_LPC134x_lib.h" //contains code for UART, Timer & to retarget printf().

#define VREF       3.3 //Reference Voltage at VREFP pin, given VREFN = 0V(GND)
#define ADC_CLK_EN (1<<13) //Enable ADC clock
#define SEL_AD0    (1<<0) //Select Channel AD0
#define CLKDIV     15 // ADC clock-divider (ADC_CLOCK=PCLK/CLKDIV+1), yields 4.5Mhz ADC clock
#define ADC_PWRUP  (~(1<<4)) //setting it to 0 will power it up
#define START_CNV  (1<<24) //001 for starting the conversion immediately
#define ADC_DONE   (1U<<31) //define it as unsigned value or compiler will throw warning
#define ADC_BURST  (1<<16) //Enable burst(hardware) mode
#define ADCR_SETUP_BURST ((CLKDIV<<8) | ADC_BURST)

int AD0Result = 0;

int main(void)
{
	//SystemInit(); //Gets called by Startup code, sets CCLK=100Mhz, PCLK=25Mhz
	initUART(); //Initialize UART for printf()
	initTimer0(); //For delayMS()

	LPC_SYSCON->PDRUNCFG &= ADC_PWRUP; //Power-up ADC Block
	LPC_SYSCON->SYSAHBCLKCTRL |= ADC_CLK_EN; //Enable ADC clock
	LPC_ADC->CR =  ADCR_SETUP_BURST | SEL_AD0; //Setup ADC Block

	/* Now select AD0 function and set ADMODE=0 for PIO0_11(P0.11) */
	LPC_IOCON->R_PIO0_11 = 0x2; //Use this for KEIL and LPCXpresso/MCUXpresso - check tutorial for more
	//LPC_IOCON->JTAG_TDI_PIO0_11 = 0x2; //Older version of CMSIS uses this. Uncomment this for CoIDE.

	LPC_ADC->INTEN = SEL_AD0; //Enable AD0 Interrupt, set ADGINTEN to 0
	NVIC_EnableIRQ(ADC_IRQn); //Enable ADC IRQ
	float voltage = 0;

	printf("OCFreaks.com LPC134x ADC Interrupt Tutorial Example.\n");
	printf("BURST/Hardware-Controlled ADC Mode on AD0 Channel.\n");
	while(1)
	{
		voltage = ((float)AD0Result * VREF) / 1024;
		printf("AD0 = %dmV\n" , (int)(voltage*1000)); //Print millivolts
		delayMS(500); //Slowing down Updates to 2 Updates per second
	}
	//return 0; //This won't execute
}

void ADC_IRQHandler(void)
{
	unsigned long ADC_GDR_Read = LPC_ADC->GDR;
	int channel = (ADC_GDR_Read>>24) & 0x7; //Extract Channel Number
	int currentResult = (ADC_GDR_Read>>6) & 0x3FF; //Extract Conversion Result

	if(channel == 0)
	{
		AD0Result = LPC_ADC->DR0; //Dummy read to Clear Done bit
		AD0Result = currentResult;
	}
}

The post LPC1343 ADC Programming Tutorial appeared first on OCFreaks!.

ARM Cortex-M0 LPC1343 UART Block

ARM Cortex-M0 LPC134x micro-controllers have only 1 UART block. UART block takes it input clock as CCLK since for LPC134x PCLK=CCLK. By default, after reset the input clock for UART is disabled. Hence to use it, we need to enable its input clock. For LPC1311/13/42/43 part numbers the TxD and RxD pins must configured using IOCON register before enabling the UART clock. This sequence is not mandatory for LPC1311/01 and LPC1313/01. Since we will be using LPC1343 MCU, we will have to use the clock enable sequence for UART examples given in the Examples section. Please check the user-manual to verify if the sequence is applicable for your LPC13xx device. Pin mapping for TXD and RXD pins is as given below:

The UART block internally has a 16-byte FIFO (First In First Out) structure to hold data. Each byte in this FIFO represents a character which was sent or received in order. It also contains two registers each, for data access and assembly as given below:

• Tx has THR(Transmit Holding Register) and TSR(Transmit Shift Register) – When we write Data to be sent into THR it is then transferred to TSR which assembles the data to be transmitted via Tx Pin.
• Similarly Rx has RSR(Receive Shift Register) and RBR(Receive Buffer Register) – When a valid data is Received at Rx Pin it is first assembled in RSR and then passed in to Rx FIFO which can be then accessed via RBR.

LPC1343 UART Registers

Before we can do any UART/Serial communication, first we need to configure and initialize the UART block in LPC134x microcontroller. But before doing that, lets go through some of the important registers used in LPC134x UART programming:

LPC134x UART Baud Rate Calculations

Now we know the formula, how do we actually start ?

1) The Dirty and Simplest Method:

The quickest and also the dirtiest(accuracy wise) method without using any algorithm or fine-tuning is to set DLM=0 and disable the Fractional Divider(i.e DIVADDVAL=0). In this case MULVAL=1 and DIVADDVAL=0 which makes the Fraction Part(FP) = 1. Now we are left with only 1 unknown in the equation which is DLL and hence we simplify the equation and solve for UxDLL.

In my opinion, if possible, you must stay away from above method as it works only for particular bauds & specific PCLK value and moreover computed DLL might get out of range i.e. > 255 in which case you have to start increasing DLM and recompute a new value for DLL. This method works for 115200 desired baud when UART_PCLK = 72Mhz, 48Mhz and 24Mhz.

2) A better Method/Algorithm (Recommended):

In these method we again start with DLM=0 , DIVADDVAL=0(i.e. Fractional divider disabled) and MULVAL=1 and get an initial value for DLM. If you are lucky you will get a very close baudrate to the desired one. If not then we perform some fine-tuning using DLM, MULVAL and DIVADDVAL and get a new value for DLM. The Algorithm which I have given below is a basic one suitable for beginners. A more invloved Iterative Algorithm is given on Page 202(Rev 5) under section 12.6.15.1 of the user manual.

When using 72Mhz clock we get DLL = 39.06 with the 1st method, hence we can use DLL = 39 since DLL must be an integer to get Actual Baud = 115384.6(~115384) with an relative error of 0.16% only. Similary when UART_PCLK = 48Mhz we can use DLL = 26 for Baud mentioned above. In both cases we were lucky to get a DLL very close to an integer, but not when we use a clock of 12.5Mhz or change the desired baud to something like 9600.

How to Configure UART in LPC134x

Once you know how UART/Serial communication works, configuring and initializing UART is pretty straight forward. In Source Code Examples for this tutorial we will use the following configuration:

• BaudRate = 115200 (with UART_PCLK=CCLK=72Mhz)
• Data Length = 8 bits
• No Parity Bit
• and 1 Stop Bit

Note: Please make it sure that configuration is same on both the communicating ends.

As seen in example above: in order to get ~115200 bauds at 72Mhz UART_PCLK we must use the following settings for baud generation :

Now, lets write a function “InitUART()” which we can use initialize and configure UART0:

#define MULVAL      1
#define DIVADDVAL   0
#define Ux_FIFO_EN  (1<<0)
#define Rx_FIFO_RST (1<<1)
#define Tx_FIFO_RST (1<<2)
#define DLAB_BIT    (1<<7)
#define LINE_FEED   0x0A //LF, For Linux, MAC and Windows Terminals
#define CARRIAGE_RETURN 0x0D //CR, For Windows Terminals (CR+LF).

void initUART(void)
{
	/*Assuming CCLK=72Mhz!*/

	//UART CLOCK Enable Sequence Step 1 - Select TXD,RXD functions
	LPC_IOCON->PIO1_6 = 0x1; //Select RXD for PIO1_6
	LPC_IOCON->PIO1_7 = 0x1; //Select RXD for PIO2_6

	//UART CLOCK Enable Sequence Step 2 - Set Divider & Enable Clock
	LPC_SYSCON->UARTCLKDIV = 1; //Set Divider by 1, so UART_PCLK=CCLK
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<12);//Enable UART clock

	LPC_UART->LCR = 3 | DLAB_BIT ; /* 8 bits, no Parity, 1 Stop bit & DLAB set to 1  */
	LPC_UART->DLL = 39; /*As per our calculations*/
	LPC_UART->DLM = 0;

	//LPC_UART0->IER |= ..; //Edit this if want you to use UART interrupts
	LPC_UART->FCR |= Ux_FIFO_EN | Rx_FIFO_RST | Tx_FIFO_RST;
	LPC_UART->FDR = (MULVAL<<4) | DIVADDVAL; /* MULVAL=15(bits - 7:4) , DIVADDVAL=2(bits - 3:0)  */
	LPC_UART->LCR &= ~(DLAB_BIT);
	//Now since we have applied DLL and DLM we now lock or freeze those values by disabling DLAB i.e DLAB=0
	//Baud= ~115200. Now we can perform UART communication!
}

Once this is done you are now ready to transfer data using RBR and THR registers.

Connections between MCU and PC or Laptop

Here we can have 2 possible scenarios.

1. Your PC/Laptop(older ones) already has a serial port. In this case you will need a RS232 to TTL converter.
2. Your PC/Laptop doesn’t have a serial port and you are using USB to Serial converter(FTDI ones, etc..).

Please refer to the connection diagrams & terminal software configuration(and COM ports) as given in Basic Uart Tutorial.

Here is a configuration screenshot for terminal software PuTTYtel which we will be using for examples :

Note: You can get PuTTYtel from Here. Direct download link: Here. You can also use other similar terminal software as well.

LPC1343 UART Examples with Source Code

Now its time to actually use UART in real life! Lets do some communication between your LPC134x MCU and PC/Laptop. The code is based on CMSIS which is the Base library for ARM Cortex Micrcontrollers.

Example 1: Hello World using UART Example

This demo will print “Hello from LPC1343!” on a new line in Serial Terminal repeatedly. The code given below uses Carriage-Return + Line-Feed (i.e. CR+LF) as New-Line(Enter or “\n”) character. If you are using Terminal on Linux or MacOS for interfacing LPC134x then only use Line-Feed(LF) character for New-Line. The function uartWrite() is used to transmit data one BYTE at a time. The output of this example is shown below:

Source Code:

/*(C) Umang Gajera - www.ocfreaks.com
More Embedded tutorials @ www.ocfreaks.com/cat/embedded/
LPC1343 UART Example 1 Source Code.
License: GPL.*/

#include <lpc13xx.h>

#define THRE        (1<<5) //Transmit Holding Register Empty
#define MULVAL      1
#define DIVADDVAL   0
#define Ux_FIFO_EN  (1<<0)
#define Rx_FIFO_RST (1<<1)
#define Tx_FIFO_RST (1<<2)
#define DLAB_BIT    (1<<7)
#define LINE_FEED   0x0A //LF, For Linux, MAC and Windows Terminals
#define CARRIAGE_RETURN 0x0D //CR, For Windows Terminals (CR+LF).

void initUART(void);
void uartWrite(char data);

int main(void)
{
	//SystemInit(); //This already gets called by CMSIS Startup Code, sets CCLK=72Mhz
	char msg[] = { 'H','e','l','l','o',' ','f','r','o','m',' ','L','P','C','1','3','4','3','\0' };
	int count=0;

	initUART();

	while(1)
	{
		while( msg[count]!='\0' )
		{
			uartWrite(msg[count]);
			count++;
		}
		//Send NEW Line Character(s) i.e. "\n"
		uartWrite(CARRIAGE_RETURN); //Comment this for Linux or MacOS
		uartWrite(LINE_FEED); //Windows uses CR+LF for newline.
		count=0; // reset counter
	}
	//return 0; //This won't execute normally
}

void uartWrite(char txData)
{
	while(!(LPC_UART->LSR & THRE)); //wait until THR is empty
	//now we can write to Tx FIFO
	LPC_UART->THR = txData;
}

void initUART(void)
{
	/*Assuming CCLK=UART_PCLK=72Mhz!*/

	//UART CLOCK Enable Sequence Step 1 - Select TXD,RXD functions
	LPC_IOCON->PIO1_6 = 0x1; //Select RXD for PIO1_6
	LPC_IOCON->PIO1_7 = 0x1; //Select RXD for PIO2_6

	//UART CLOCK Enable Sequence Step 2 - Set Divider & Enable Clock
	LPC_SYSCON->UARTCLKDIV = 1; //Set Divider by 1, so UART_PCLK=CCLK
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<12);//Enable UART clock

	LPC_UART->LCR = 3 | DLAB_BIT ; /* 8 bits, no Parity, 1 Stop bit & DLAB set to 1  */
	LPC_UART->DLL = 39;
	LPC_UART->DLM = 0;

	LPC_UART->FCR |= Ux_FIFO_EN | Rx_FIFO_RST | Tx_FIFO_RST;
	LPC_UART->FDR = (MULVAL<<4) | DIVADDVAL; /* MULVAL=15(bits - 7:4) , DIVADDVAL=2(bits - 3:0)  */
	LPC_UART->LCR &= ~(DLAB_BIT);
	//Now since we have applied DLL and DLM we now lock or freeze those valuse by diabling DLAB i.e DLAB=0
	//Baud= ~115200. Now we can perform UART communication!
}

Example 2: Echo data in Terminal

In this example you will see the characters that you type on your keyboard i.e. we echo back the characters(data) received by MCU. Serial Terminals only displays the character that it receives via serial Port. When you type a character it is directly sent to the other side via serial port. Hence, in order for us to see the character which we typed, we need to send back the same character. This is what the program below does. Whenever MCU receives a character from the RXD pin, it will send the same character back to PC via the TXD Pin and it gets displayed in Terminal. Here I’ve defined additional function uartRead() which is used to read the recieved data one BYTE at a time.

LPC134x UART Example 2 output:

Source code:

/*(C) Umang Gajera - www.ocfreaks.com
More Embedded tutorials @ www.ocfreaks.com/cat/embedded/
LPC1343 UART Example 2 Source Code.
License : GPL.*/

#include <lpc13xx.h>

#define RDR         (1<<0) //Receiver Data Ready
#define THRE        (1<<5) //Transmit Holding Register Empty
#define MULVAL      1
#define DIVADDVAL   0
#define Ux_FIFO_EN  (1<<0)
#define Rx_FIFO_RST (1<<1)
#define Tx_FIFO_RST (1<<2)
#define DLAB_BIT    (1<<7)
#define LINE_FEED   0x0A //LF, For Linux, MAC and Windows Terminals
#define CARRIAGE_RETURN 0x0D //CR, For Windows Terminals (CR+LF).
#define ENTER       CARRIAGE_RETURN //Ascii value/code for Enter is 0x0D i.e. CR

void initUART(void);
void uartWrite(char data);
char uartRead(void);

int main(void)
{
	initUART();
	char data = 0;

	while(1)
	{
		data = uartRead(); //Read Data from Rx
		if(data == ENTER || data == LINE_FEED) //Check if user pressed Enter key
		{
			//Send NEW Line Character(s) i.e. "\n"
			uartWrite(CARRIAGE_RETURN); //Comment this for Linux or MacOS
			uartWrite(LINE_FEED); //Windows uses CR+LF for newline.
		}
		else
		{
			uartWrite(data); //Tx Read Data back
		}
	}
	//return 0; //Normally this won't execute
}

char uartRead(void)
{
	while(!(LPC_UART->LSR & RDR)); //wait until data arrives in Rx FIFO
	return LPC_UART->RBR;
}

void uartWrite(char txData)
{
	while(!(LPC_UART->LSR & THRE)); //wait until THR is empty
	//now we can write to Tx FIFO
	LPC_UART->THR = txData;
}

void initUART(void)
{
	/*Assuming CCLK=UART_PCLK=72Mhz!*/

	//UART CLOCK Enable Sequence Step 1 - Select TXD,RXD functions
	LPC_IOCON->PIO1_6 = 0x1; //Select RXD for PIO1_6
	LPC_IOCON->PIO1_7 = 0x1; //Select RXD for PIO2_6

	//UART CLOCK Enable Sequence Step 2 - Set Divider & Enable Clock
	LPC_SYSCON->UARTCLKDIV = 1; //Set Divider by 1, so UART_PCLK=CCLK
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<12);//Enable UART clock

	LPC_UART->LCR = 3 | DLAB_BIT ; /* 8 bits, no Parity, 1 Stop bit & DLAB set to 1  */
	LPC_UART->DLL = 39;
	LPC_UART->DLM = 0;

	LPC_UART->FCR |= Ux_FIFO_EN | Rx_FIFO_RST | Tx_FIFO_RST;
	LPC_UART->FDR = (MULVAL<<4) | DIVADDVAL; /* MULVAL=15(bits - 7:4) , DIVADDVAL=2(bits - 3:0)  */
	LPC_UART->LCR &= ~(DLAB_BIT);
	//Now since we have applied DLL and DLM we now lock or freeze those values by disabling DLAB i.e DLAB=0
	//Baud= ~115200. Now we can perform UART communication!
}

The post LPC1343 UART Programming Tutorial appeared first on OCFreaks!.

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

In this discussion we will go through ARM Cortex-M3 LPC1343 Timer Tutorial. Previously we saw a blinky example using GPIO and hardcoded delays, now its time to improvise and use precise delay using timers. LPC1343 has 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 and is also applicable to similar MCUs like LPC1347.

Timer Module in LPC134x

Each Timer module in ARM Cortex-M3 LPC134x microcontroller 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.

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. This Match output is diverted to a physical pin on the MCU by selecting CT32Bx_MATn alternate function for the pin which supports it.

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.

LPC1343 which is found on LPCXpresso Board has four Match Outputs and one Capture Input.

LPC134x Timer Registers

We will be using CMSIS based lpc13xx.h (ARM Cortex M3) 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-referencing 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.

Setting up & configuring Timers in LPC1343

To use timers we need to first configure 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) – PIO0_11 (R_PIO0_11)
• Timer1 MAT 0 (CT32B1_MAT0) – PIO1_1 (R_PIO1_1)
• Timer1 MAT 1 (CT32B1_MAT1) – PIO1_2 (R_PIO1_1)
• Timer1 MAT 2 (CT32B1_MAT2) – PIO1_3 (SWDIO_PIO1_3)
• Timer1 MAT 3 (CT32B1_MAT3) – PIO1_4

The name inside brackets above represent actual member(IOCON register) names of LPC_IOCON structure, if brackets are present. 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)

LPC1343 Timer Examples with sample code

Example 1) – LPC134x 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). An LED is connected to Pin PIO0_7 which is present on LPCXpresso 1343 board.

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

#include <lpc13xx.h>

#define PRESCALE (72000-1) //72000 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) = 72Mhz (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 71999+1 clock cycles
	//72000 clock cycles @72Mhz = 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) – LPC134x 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/
LPC1343 Timer example 2.*/

#include <lpc13xx.h>

#define PRESCALE (72000-1) //72000 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) = 72Mhz (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 71999+1 clock cycles
	//72000 clock cycles @72Mhz = 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
}

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

Most of the function pins on LPC1343 Micro-controllers are grouped into Ports. LPC1343 has 4 ports viz. Port 0 to 3. 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 depending you MCU package each port may have a few or many pins which cannot be used i.e. they are ‘reserved’. For this tutorial I will be using LPC1343 in LQFP48 package as reference. For HVQFN33 package please refer table no. 146 on page 132 of the user-manual (Rev 5) for which pins are available for use.

For LPC1343 (LQFP48):

• All 12 pins on Ports 0, 1 and 2 are avialable.
• On Port 3 only first 4 pins (i.e. PIO3_0 to PIO3_3) are available. Rest of the pins are reserved.

GPIO Registers in LPC134x

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 functional pin on LPC1343 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 LPC1343 in my previous tutorial : LPC11xx and LPC13xx LPC_IOCON Register Tutorial

Most of the PINS of LPC134x MCU are Multiplexed i.e. these pins can be configured to provide up to 4 different functions. Not all pins on LPC134x 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.

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

LPC13xx.h header is based on CMSIS(Cortex Microcontroller System Interface Standard) developed by ARM. The register definitions for Cortex-M3 LPC134x 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.

LPC_GPIOx is defined as a pointer to a structure, which contains GPIO registers for Port x, in LPC13xx.h header. 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 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 LPC134x 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 6 of Port 1 as output. It can be done in following ways:

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

CASE 2. LPC_GPIO1->DIR |= 0x0000040; //or 0x40; (hexadecimal - OR and assign: other pins not affected)

CASE 3. LPC_GPIO1->DIR |= (1<<6); //(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 PIO1_6 ‘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 you want to change bits 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 which are assigned to Registers. For eg. 0x7F and 0x07F and 0x007F all mean the same.

example codes:

Ex. 1)

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

LPC_GPIO0->DIR |= (1<<8); //Config PIO0_8 as Ouput
LPC_GPIO0->DATA |= (1<<8); //Drive PIO0_8 HIGH

Ex. 2)

Driving Pin 5 HIGH of Port 1 i.e PIO1_5(P1.5) and then LOW can be does as follows:

LPC_GPIO1->DIR |= (1<<5); //Set PIO1_5 as Output
LPC_GPIO1->DATA |= (1<<5); //PIO1_5 driven HIGH
LPC_GPIO1->DATA &= ~(1<<5); //PIO1_5 driven LOW

Ex. 3)

Configuring PIO0_6(P0.6) and PIO0_2(P0.2) as Output and Setting them High:

LPC_GPIO0->DIR |= (1<<6) | (1<<2); //Config PIO0_6 and PIO0_2 as Output
LPC_GPIO0->DATA |= (1<<6) | (1<<2); //Drive Output High for PIO0_6 and PIO0_2

Ex. 4)

Configuring Pins 0 to 7 of Port 2 (PIO2_0 to PIO2_7) as Output and Setting them High:

LPC_GPIO2->DIR |= 0xFF; //Set PIO2_0 to PIO2_7 as Output
LPC_GPIO2->DATA |= 0xFF; //Drive PIO2_0 to PIO2_7 HIGH

Ex. 5)

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

LPC_GPIO2->DIR &= ~(1<<10); //Config PIO1_5 as input (It will be anyways input after reset)
LPC_IOCON->PIO2_10 = (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 which occurs until the contacts of the switch have stabilized. This can be filtered out using deboucning techniques, either in Software or Hardware.

Now lets play with some real world examples.

Ex. 6)

LPC13xx Blinky Example Code - Here we drive pin 7 of port 0 (PIO0_7) repeatedly high to low. PIO0_7(P0.7) of LPC13xx devices have High 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 <lpc13xx.h>

void delay(void);

int main(void)
{
	LPC_GPIO0->DIR = (1<<7); //Config PIO0_7 as Output
	
	while(1)
	{
		LPC_GPIO0->DATA = (1<<7); //Drive output HIGH to turn LED ON
		// Better way would be LPC_GPIO0->DATA |= (1<<7);
		
		delay();
		LPC_GPIO0->DATA = 0x0; //Drive output LOW to turn LED OFF
		// 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 < 4500000; 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 it will turn the LED. 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 <lpc13xx.h>

int main(void)
{
	LPC_GPIO1->DIR &= ~((1<<5)) ; //config PIO1_5 as Input
	LPC_GPIO0->DIR |= (1<<7); //config PIO0_7 as Output

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

	while(1)
	{
		if( LPC_GPIO1->DATA & (1<<5) ) //Evaluates to True if PIO1_5 is HIGH
		{
			LPC_GPIO0->DATA |= (1<<7); //drive PIO0_7 High to turn LED ON
			//Now PIO0_7 will be held high unless the MCU is reset
		}
	}
	return 0; //this won't 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 <lpc13xx.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, LED = ON
		}
		else
		{
			LPC_GPIO0->DATA &= ~(1<<7); //Input HIGH, LED = OFF
		}
	}
	return 0; //normally this won't execute
}

The post LPC1343 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!.