INDEX

Sl No Part A Experiments list

1 ALP to multiply two 16 bit binary numbers.
2 ALP to find the sum of first 10 integer numbers.
3 ALP to find the number of 0’s and 1’s in a 32 bit data.
4 ALP to find determine whether the given 16 bit is even or odd
5 ALP to write data to RAM
Part B Experiments list
6 Experiment No1: Display Hello word in UART

7 Experiment No 2:-Speed Control of the DC Motor

8 Experiment No 3:-Stepper Motor Interface and rotate clockwise and

anticlockwise

9 Experiment No 4:-Display digital output for given analog input using

internal ADC

10 Experiment No 5:-Interface DAC and generate Triangular and Square

Waveform

11 Experiment No 6:-Interface 4X4 Matrix Keypad and display in LCD

12 Experiment No 7:-Using external interrupt switches toggle the led’s

13 Experiment No 8:-Display 0-F in 7 segment display

14 Experiment No 9:-Interface SPI ADC and display Ambient temperature

pg. 1
 Experiment No 1

;//An ALP to multiply two 16 bit binary numbers.

;/* VALUE1: 1900H (6400) (IN R1) */

;/* VALUE2: 0C80H (3200) (IN R2) */

;/* RESULT: 1388000H(20480000) (IN R3) */

AREA MULTIPLY, CODE, READONLY

EXPORT __main

__main

ENTRY

START

MOV r1,#6400

MOV r2,#3200

MUL r3,r1,r2

NOP

NOP

NOP

END

pg. 2
 Experiment No 2

;/ An ALP to find the sum of first 10 integer numbers.

;/* In this example we have taken n=10 */
;/* Check the result in R0/R3 register =37H (55) */

AREA ADD1to10, CODE, READONLY

EXPORT __main
__main
MOV r0, #10
MOV r1,r0

rpt
SUBS r1, r1, #1
CMP r1, #0
BEQ STOP
ADD r3,r0,r1
MOV r0,r3
BNE rpt
STOP

NOP
NOP
NOP

END

pg. 3
 Experiment No 3

;/ An ALP to add an array of 16 bit numbers and store the 32 bit result in internal RAM
;/* ARRAY OF 6 NUMBERS 0X1111,0X2222,0X3333,0XAAAA,0XBBBB,0XCCCC */
;/* THE SUM IS 29997H THE RESULT CAN BE VIEWED IN LOCATION 0X40000000 & ALSO IN R0*/

AREA ADDITION , CODE, READONLY

EXPORT __main
__main
ENTRY

START
MOV R5,#6
MOV R0,#0
LDR R1,=VALUE1
LOOP
LDR R2,[R1],#2
LDR R3,MASK
AND R2,R2,R3
ADD R0,R0,R2
SUBS R5,R5,#1
CMP R5,#0
BNE LOOP
LDR R4,=RESULT
STR R0,[R4]

NOP
NOP
NOP

MASK DCD 0X0000FFFF

VALUE1 DCW 0X1111,0X2222,0X3333,0XAAAA,0XBBBB,0XCCCC

AREA DATA2,DATA,READWRITE

RESULT DCD 0X0

END

pg. 4
 Experiment No 4

;/* PROGRAM TO COUNT THE NUMBER OF ONES & ZEROS IN TWO CONSECUTIVE MEMORY LOCATIONS
*/
;/* WE TOOK TWO NUMBERS i.e. 0X11111111,0XAA55AA55 (R0) */
;/* CHECK THE RESULT IN R2 FOR ONES & R3 FOR ZEROS */
;/* SET A BREAKPOINT AT NOP INSTRUCTION,RUN THE PROGRAM & CHECK THE RESULT */

AREA ONEZERO , CODE, READONLY

EXPORT __main
__main
ENTRY

START

MOV R2,#0
MOV R3,#0
MOV R7,#2
LDR R6,=VALUE

LOOP MOV R1,#32

LDR R0,[R6],#4

LOOP0 MOVS R0,R0,ROR #1

BHI ONES

ZEROS ADD R3,R3,#1

B LOOP1

ONES ADD R2,R2,#1

LOOP1 SUBS R1,R1,#1

BNE LOOP0

SUBS R7,R7,#1
CMP R7,#0
BNE LOOP

NOP
NOP
NOP

VALUE DCD 0X11111111,0XAA55AA55;

END

pg. 5
 Experiment No 5

;/* PROGRAM TO FIND HOW MANY NUMBERS ARE NEGATIVE IN AN ARRAY */

;/*ARRAY OF 7 NUMBERS 0X12345678,0X8D489867,0X11111111,0X33333333,0XAAAAAAAA
0XE605546C ,0X99999999 */
;/* RESULT CAN BE VIEWED IN R2 */
;/* SET A BREAKPOINT AT NOP INSTRUCTION,RUN THE PROGRAM & CHECK THE RESULT */

AREA NEGATIVE , CODE, READONLY

EXPORT __main
__main
ENTRY

START
MOV R5,#7
MOV R2,#0
LDR R4,=VALUE

LOOP
LDR R1,[R4],#4
BHI FOUND
B LOOP1

FOUND
ADD R2,R2,#1
B LOOP1
LOOP1
SUBS R5,R5,#1
CMP R5,#0
BNE LOOP

NOP
NOP
NOP

;ARRAY OF 32 BIT NUMBERS(N=7)

VALUE
DCD 0X12345678 ;
DCD 0X8D489867 ;
DCD 0X11111111 ;
DCD 0X33333333 ;
DCD 0XE605546C ;
DCD 0XAAAAAAAA ;
DCD 0X99999999 ;

END

pg. 6
Experiment No1: Display Hello word in UART

Main Code:-

#include <lpc17xx.h>
#include "stdutils.h"

#define SBIT_WordLenght 0x00u

#define SBIT_DLAB 0x07u
#define SBIT_FIFO 0x00u
#define SBIT_RxFIFO 0x01u
#define SBIT_TxFIFO 0x02u

#define SBIT_RDR 0x00u

#define SBIT_THRE 0x05u

/* Function to initialize the UART0 at specifief baud rate */

void uart_init(uint32_t baudrate)
{
uint32_t var_UartPclk_u32,var_Pclk_u32,var_RegValue_u32;

LPC_PINCON->PINSEL0 &= ~0x000000F0;

LPC_PINCON->PINSEL0 |= 0x00000050; // Enable TxD0 P0.2 and p0.3

LPC_UART0->FCR = (1<<SBIT_FIFO) | (1<<SBIT_RxFIFO) | (1<<SBIT_TxFIFO); // Enable FIFO and reset Rx/Tx FIFO
buffers
LPC_UART0->LCR = (0x03<<SBIT_WordLenght) | (1<<SBIT_DLAB); // 8bit data, 1Stop bit, No parity

/** Baud Rate Calculation :

PCLKSELx registers contains the PCLK info for all the clock dependent peripherals.
Bit6,Bit7 contains the Uart Clock(ie.UART_PCLK) information.
The UART_PCLK and the actual Peripheral Clock(PCLK) is calculated as below.
(Refer data sheet for more info)

UART_PCLK PCLK
0x00 SystemFreq/4
0x01 SystemFreq
0x02 SystemFreq/2
0x03 SystemFreq/8
**/

var_UartPclk_u32 = (LPC_SC->PCLKSEL0 >> 6) & 0x03;

switch( var_UartPclk_u32 )
{
case 0x00:
var_Pclk_u32 = SystemCoreClock/4;
break;
case 0x01:
var_Pclk_u32 = SystemCoreClock;
break;
case 0x02:
var_Pclk_u32 = SystemCoreClock/2;
break;
case 0x03:
var_Pclk_u32 = SystemCoreClock/8;
break;
}

var_RegValue_u32 = ( var_Pclk_u32 / (16 * baudrate ));

LPC_UART0->DLL = var_RegValue_u32 & 0xFF;
LPC_UART0->DLM = (var_RegValue_u32 >> 0x08) & 0xFF;

pg. 7
 util_BitClear(LPC_UART0->LCR,(SBIT_DLAB)); // Clear DLAB after setting DLL,DLM
}

/* Function to transmit a char */

void uart_TxChar(char ch)
{
while(util_IsBitCleared(LPC_UART0->LSR,SBIT_THRE)); // Wait for Previous transmission
LPC_UART0->THR=ch; // Load the data to be transmitted
}

int main()
{
char a[]="\n\rHello World";
int i;

SystemInit();
uart_init(9600); // Initialize the UART0 for 9600 baud rate

for(i=0;a[i];i++) //transmit a predefined string

uart_TxChar(a[i]);
}

pg. 8
Experiment No 2:-Speed Control of the DC Motor

Main code:-

#include <lpc17xx.h>

void delay_ms(unsigned int ms)// delay routine

{
unsigned int i,j;
for(i=0;i<ms;i++)
for(j=0;j<60000;j++);
}

#define SBIT_CNTEN 0 //counter enable

#define SBIT_PWMEN 2 //pwm 2 block enable

#define SBIT_PWMMR0R 1 //This bit is used to Reset PWMTC whenever it Matches PWMRx(x:0-6)

#define SBIT_PWMENA3 11 //This bit is used to enable/disable the PWM output for PWMx(x:1-6)

#define PWM_3 4 //P2_2 (0-1 Bits of PINSEL4)

int main(void)
{
int dutyCycle;
SystemInit();
/* Cofigure pins(P2_2 ) for PWM mode. */
LPC_PINCON->PINSEL4 = (1<<PWM_3) ;

/* Enable Counters,PWM module */

LPC_PWM1->TCR = (1<<SBIT_CNTEN) | (1<<SBIT_PWMEN);

LPC_PWM1->PR = 0x00; /* No Prescalar */

LPC_PWM1->MCR = (1<<SBIT_PWMMR0R); /*Reset on PWMMR0, reset TC if it matches MR0 */

LPC_PWM1->MR0 = 100; /* set PWM cycle(Ton+Toff)=100) */

/* Enable the PWM output pins for PWM_1-PWM_4(P2_0 - P2_3) */

LPC_PWM1->PCR = (1<<SBIT_PWMENA3);

while(1)
{

{
LPC_PWM1->MR3 = dutyCycle; /* Increase the dutyCycle from 0-100 */

delay_ms(5);
}
if(!(LPC_GPIO2->FIOPIN & 0x00000800))//if sw 23 pressed
{
while(!(LPC_GPIO2->FIOPIN & 0x00000800));

pg. 9
 dutyCycle-=10; //decrement duty cycle 10%
if(dutyCycle<0)
{
dutyCycle=0;
}
}
else if(!(LPC_GPIO2->FIOPIN & 0x00001000)) //if SW 22 pressed
{
while(!(LPC_GPIO2->FIOPIN & 0x00001000));

dutyCycle+=10; //increment duty cycle 10%

if(dutyCycle>100)
{
dutyCycle=99;
}
}

}
}

pg. 10
Experiment No 3:-Stepper Motor Interface and rotate clockwise and anticlockwise

Main code:- Step Angle Rotation

#include <lpc17xx.h>

void delay(unsigned int ms)

{
unsigned int i,j;

for(i=0;i<ms;i++)
for(j=0;j<20000;j++); //delay subroutine
}

/* start the main program */

int main()
{
int cycle;
SystemInit(); //Clock and PLL configuration

LPC_GPIO0->FIODIR |= 0x00078000; //Configure the PORT0 pins as OUTPUT;

for(cycle=0; cycle<13; cycle++)// for loop condition for number of rotation. It gives approx 90 degree rotation
{
LPC_GPIO0->FIOPIN = 0x00008000 ; // p0.15 pin
delay(100);
LPC_GPIO0->FIOPIN = 0x00010000 ;// p0.16 pin
delay(100);
LPC_GPIO0->FIOPIN = 0x00020000 ; // p0.17 pin
delay(100);
LPC_GPIO0->FIOPIN = 0x00040000 ;// p0.18 pin
delay(100);
}
}

pg. 11
Stepper motor rotation clockwise and anticlockwise.
#include "lpc17xx.h"
void delay();

void delay()
{
int i,j;
for(i=0;i<0xff;i++)
for(j=0;j<0x400;j++);
}

int main (void)

{
char rotate=0;
SystemInit();

LPC_GPIO0->FIODIR |= 0x00078000;
while(1)
{
if(rotate==1)
{
LPC_GPIO0->FIOPIN = 0x00008000 ;
delay();
LPC_GPIO0->FIOPIN = 0x00010000 ;
delay();
LPC_GPIO0->FIOPIN = 0x00020000 ;
delay();
LPC_GPIO0->FIOPIN = 0x00040000 ;
delay();
}
else
{
LPC_GPIO0->FIOPIN = 0x00040000 ;
delay();
LPC_GPIO0->FIOPIN = 0x00020000 ;
delay();
LPC_GPIO0->FIOPIN = 0x00010000 ;
delay();
LPC_GPIO0->FIOPIN = 0x00008000 ;
delay();
}

if(!(LPC_GPIO2->FIOPIN & 0x00000800))

{
while(!(LPC_GPIO2->FIOPIN & 0x00000800));

rotate=1;
}
else if(!(LPC_GPIO2->FIOPIN & 0x00001000))
{
while(!(LPC_GPIO2->FIOPIN & 0x00001000));

rotate=0;
}
}
}
pg. 12
Experiment No 4:-Display digital output for given analog input using internal ADC
#include "lpc17xx.h"
#include "lcd.h"
#define VREF 3.3 //Reference Voltage at VREFP pin, given VREFN = 0V(GND)
#define ADC_CLK_EN (1<<12)
#define SEL_AD0_2 (1<<2) //Select Channel AD0.2
#define CLKDIV 1 //ADC clock-divider (ADC_CLOCK=PCLK/CLKDIV+1) = 12.5Mhz @ 25Mhz PCLK
#define PWRUP (1<<21) //setting it to 0 will power it down
#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) | PWRUP)
////////// Init ADC0 CH2 /////////////////
Init_ADC()
{
// Convert Port pin 0.25 to function as AD0.2
LPC_SC->PCONP |= ADC_CLK_EN; //Enable ADC clock
LPC_ADC->ADCR = ADCR_SETUP_SCM | SEL_AD0_2;
LPC_PINCON->PINSEL1 |= (1<<18) ; //select AD0.2 for P0.25
}

////////// READ ADC0 CH:2 /////////////////

unsigned int Read_ADC()
{
unsigned int i=0;
LPC_ADC->ADCR |= START_CNV; //Start new Conversion
while((LPC_ADC->ADDR2 & ADC_DONE) == 0); //Wait untill conversion is finished
i = (LPC_ADC->ADDR2>>4) & 0xFFF; //12 bit Mask to extract result

}
////////// DISPLAY ADC VALUE /////////////////
Display_ADC()
{
unsigned int adc_value = 0;
char buf[4] = {5};
float voltage = 0.0;
adc_value = Read_ADC();
sprintf((char *)buf, "%3d", adc_value); // display 3 decima place
lcd_putstring16(0,"ADC VAL = 000 "); //1st line display
lcd_putstring16(1,"Voltage 00 V"); //2nd line display
lcd_gotoxy(0,10);
lcd_putstring(buf);
voltage = (adc_value * 3.3) / 4095 ;
lcd_gotoxy(1,8);
sprintf(buf, "%3.2f", voltage);
lcd_putstring(buf);
}
////////// MAIN /////////////////
int main (void)
{
init_lcd();
Init_ADC();
lcd_putstring16(0,"** MICROLAB **");
lcd_putstring16(1,"** INSTRUMENTS **");
delay(60000);
delay(60000);
delay(60000);
lcd_putstring16(0,"ADC Value.. ");
lcd_putstring16(1,"voltage.......");
while(1)
{
Display_ADC();
delay(100000);

pg. 13
 }
}

LCD Code:-

#include "lpc17xx.h"
#include "lcd.h"
void Lcd_CmdWrite(unsigned char cmd);
void Lcd_DataWrite(unsigned char dat);
#define LCDRS 9
#define LCDRW 10
#define LCDEN 11
#define LCD_D4 19
#define LCD_D5 20
#define LCD_D6 21
#define LCD_D7 22
#define LcdData LPC_GPIO0->FIOPIN
#define LcdControl LPC_GPIO0->FIOPIN
#define LcdDataDirn LPC_GPIO0->FIODIR
#define LcdCtrlDirn LPC_GPIO0->FIODIR
#define LCD_ctrlMask ((1<<LCDRS)|(1<<LCDRW)|(1<<LCDEN))
#define LCD_dataMask ((1<<LCD_D4)|(1<<LCD_D5)|(1<<LCD_D6)|(1<<LCD_D7))
void delay(unsigned int count)
{
int j=0, i=0;
for (j=0;j<count;j++)
for (i=0;i<50;i++);
}

void sendNibble(char nibble)

{
LcdData&=~(LCD_dataMask); // Clear previous data
LcdData|= (((nibble >>0x00) & 0x01) << LCD_D4);
LcdData|= (((nibble >>0x01) & 0x01) << LCD_D5);
LcdData|= (((nibble >>0x02) & 0x01) << LCD_D6);
LcdData|= (((nibble >>0x03) & 0x01) << LCD_D7);
}
void Lcd_CmdWrite(unsigned char cmd)
{
sendNibble((cmd >> 0x04) & 0x0F); //Send higher nibble
LcdControl &= ~(1<<LCDRS); // Send LOW pulse on RS pin for selecting Command register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
delay(100);
LcdControl &= ~(1<<LCDEN);

delay(10000);

sendNibble(cmd & 0x0F); //Send Lower nibble

LcdControl &= ~(1<<LCDRS); // Send LOW pulse on RS pin for selecting Command register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
delay(100);
LcdControl &= ~(1<<LCDEN);

delay(1000);
}

void Lcd_DataWrite(unsigned char dat)

{
sendNibble((dat >> 0x04) & 0x0F); //Send higher nibble
LcdControl |= (1<<LCDRS); // Send HIGH pulse on RS pin for selecting data register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
pg. 14
 delay(100);
LcdControl &= ~(1<<LCDEN);
delay(1000);
sendNibble(dat & 0x0F); //Send Lower nibble
LcdControl |= (1<<LCDRS); // Send HIGH pulse on RS pin for selecting data register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
delay(100);
LcdControl &= ~(1<<LCDEN);
delay(1000);
}
void lcd_clear( void)
{
Lcd_CmdWrite( 0x01 );
}
int lcd_gotoxy( unsigned char x, unsigned char y)
{
unsigned char retval = TRUE;

if( (x > 1) && (y > 15) )

{
retval = FALSE;
}
else
{
if( x == 0 ) Lcd_CmdWrite( 0x80 + y ); //Move the cursor to beginning of the first line
else if( x==1 ) Lcd_CmdWrite( 0xC0 + y );// Move the cursor to beginning of the second line
}
return retval;
}
void lcd_putchar( unsigned char c )
{
Lcd_DataWrite( c );
}
void lcd_putstring( char *string )
{
while(*string != '\0')
{
lcd_putchar( *string );
string++;
}
}
void lcd_putstring16( unsigned char line, char *string )
{
unsigned char len = 16;

lcd_gotoxy( line, 0 );
while(*string != '\0' && len--)
{
lcd_putchar( *string );
string++;
}
}
void init_lcd( void )
{
LcdDataDirn |= LCD_dataMask; // Configure all the LCD pins as output
LcdCtrlDirn |= LCD_ctrlMask;
Lcd_CmdWrite(0x03);//
delay(2000);
Lcd_CmdWrite(0x03);//
delay(1000);
Lcd_CmdWrite(0x03);//
delay(100);

pg. 15
Lcd_CmdWrite(0x2);// Initialize LCD in 4-bit mode
Lcd_CmdWrite(0x28);// enable 5x7 mode for chars
Lcd_CmdWrite(0x0e);// Display OFF, Cursor ON
Lcd_CmdWrite(0x06);//Entry mode
Lcd_CmdWrite(0x01);// Clear Display
delay(1);
}

pg. 16
Experiment No 5:-Interface DAC and generate Triangular and Square Waveform

Triangle wave generation:-

#include "LPC17xx.h"
uint32_t val;
int main()
{
SystemInit();
LPC_PINCON->PINSEL1 |= 0x02<<20; //p0.26 pinsel bits 20 and 21
while(1)
{
while(1)
{
val++;// increment values by 6
LPC_DAC->DACR=(val<<6);//send values to dac
if(val>=0x3ff)// if value exceeds 1024
{
break;
}
}
while(1)
{
val--; // decrement value by 6
LPC_DAC->DACR=(val<<6);// send value to dac
if(val<=0x000)// if value come down by 0
{
break;
}
}
}

pg. 17
Square Wave generation:-

#include "LPC17xx.h"
void delay(unsigned int ms)// delay subroutine
{
unsigned int i,j;

for(i=0;i<ms;i++)
for(j=0;j<2000;j++);
}
int main()
{
SystemInit();
LPC_PINCON->PINSEL1 |= 0x02<<20;//p0.26 pinsel bits 20 and 21

while(1)
{
LPC_DAC->DACR=0xffff;// send maximum values to dac

delay(20); // delay

LPC_DAC->DACR=0x0000;// send min values to dac

delay(20);
}

pg. 18
Experiment No 6:-Interface 4X4 Matrix Keypad and display in LCD
Main code:-

#include "lpc17xx.h"
#include "lcd.h"

/////////////////////////////////////////////
// Matrix Keypad Scanning Routine
//
// COL1 COL2 COL3 COL4
// 0 1 2 3 ROW 1
// 4 5 6 7 ROW 2
// 8 9 A B ROW 3
// C D E F ROW 4
//////////////////////////////////////////////

#define COL1 0
#define COL2 1
#define COL3 4
#define COL4 8

#define ROW1 9
#define ROW2 10
#define ROW3 14
#define ROW4 15

#define COLMASK ((1<<COL1) |(1<< COL2) |(1<< COL3) |(1<< COL4))

#define ROWMASK ((1<<ROW1) |(1<< ROW2) |(1<< ROW3) |(1<< ROW4))

#define KEY_CTRL_DIR LPC_GPIO1->FIODIR

#define KEY_CTRL_SET LPC_GPIO1->FIOSET
#define KEY_CTRL_CLR LPC_GPIO1->FIOCLR
#define KEY_CTRL_PIN LPC_GPIO1->FIOPIN

/////////////// COLUMN WRITE /////////////////////

void col_write( unsigned char data )
{
unsigned int temp=0;

temp=(data) & COLMASK;

KEY_CTRL_CLR |= COLMASK;
KEY_CTRL_SET |= temp;
}

///////////////////////////////// MAIN ///////////////////////////////////////

int main (void)
{
unsigned char key, i;
unsigned char rval[] = {0x77,0x07,0x0d};
unsigned char keyPadMatrix[] =
{
'4','8','B','F',
'3','7','A','E',
'2','6','0','D',
'1','5','9','C'
};
SystemInit();
init_lcd();

KEY_CTRL_DIR |= COLMASK; //Set COLs as Outputs

KEY_CTRL_DIR &= ~(ROWMASK); // Set ROW lines as Inputs

pg. 19
 lcd_putstring16(0,"Press HEX Keys..");// 1st line display
lcd_putstring16(1,"Key Pressed = ");// 2nd line display

while (1)
{
key = 0;
for( i = 0; i < 4; i++ )
{
// turn on COL output one by one
col_write(rval[i]);

// read rows - break when key press detected

if (!(KEY_CTRL_PIN & (1<<ROW1)))
break;

key++;
if (!(KEY_CTRL_PIN & (1<<ROW2)))
break;

key++;
if (!(KEY_CTRL_PIN & (1<<ROW3)))
break;

key++;
if (!(KEY_CTRL_PIN & (1<<ROW4)))
break;

key++;
}

if (key == 0x10)
lcd_putstring16(1,"Key Pressed = ");
else
{
lcd_gotoxy(1,14);
lcd_putchar(keyPadMatrix[key]);
}
}

LCD code:-

#include "lpc17xx.h"
#include "lcd.h"
void Lcd_CmdWrite(unsigned char cmd);
void Lcd_DataWrite(unsigned char dat);
#define LCDRS 9
#define LCDRW 10
#define LCDEN 11

#define LCD_D4 19
#define LCD_D5 20
#define LCD_D6 21
#define LCD_D7 22
#define LcdData LPC_GPIO0->FIOPIN
#define LcdControl LPC_GPIO0->FIOPIN
#define LcdDataDirn LPC_GPIO0->FIODIR
#define LcdCtrlDirn LPC_GPIO0->FIODIR
#define LCD_ctrlMask ((1<<LCDRS)|(1<<LCDRW)|(1<<LCDEN))
#define LCD_dataMask ((1<<LCD_D4)|(1<<LCD_D5)|(1<<LCD_D6)|(1<<LCD_D7))
void delay(unsigned int count)
pg. 20
{
int j=0, i=0;
for (j=0;j<count;j++)
for (i=0;i<30;i++);
}

void sendNibble(char nibble)

{
LcdData&=~(LCD_dataMask); // Clear previous data
LcdData|= (((nibble >>0x00) & 0x01) << LCD_D4);
LcdData|= (((nibble >>0x01) & 0x01) << LCD_D5);
LcdData|= (((nibble >>0x02) & 0x01) << LCD_D6);
LcdData|= (((nibble >>0x03) & 0x01) << LCD_D7);
}

void Lcd_CmdWrite(unsigned char cmd)

{
sendNibble((cmd >> 0x04) & 0x0F); //Send higher nibble
LcdControl &= ~(1<<LCDRS); // Send LOW pulse on RS pin for selecting Command register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
delay(100);
LcdControl &= ~(1<<LCDEN);

delay(10000);

sendNibble(cmd & 0x0F); //Send Lower nibble

LcdControl &= ~(1<<LCDRS); // Send LOW pulse on RS pin for selecting Command register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
delay(100);
LcdControl &= ~(1<<LCDEN);

delay(1000);
}

void Lcd_DataWrite(unsigned char dat)

{
sendNibble((dat >> 0x04) & 0x0F); //Send higher nibble
LcdControl |= (1<<LCDRS); // Send HIGH pulse on RS pin for selecting data register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
delay(100);
LcdControl &= ~(1<<LCDEN);

delay(1000);

sendNibble(dat & 0x0F); //Send Lower nibble

LcdControl |= (1<<LCDRS); // Send HIGH pulse on RS pin for selecting data register
LcdControl &= ~(1<<LCDRW); // Send LOW pulse on RW pin for Write operation
LcdControl |= (1<<LCDEN); // Generate a High-to-low pulse on EN pin
delay(100);
LcdControl &= ~(1<<LCDEN);

delay(1000);
}
void lcd_clear( void)
{
Lcd_CmdWrite( 0x01 );
}
int lcd_gotoxy( unsigned char x, unsigned char y)
{
unsigned char retval = TRUE;
pg. 21
 if( (x > 1) && (y > 15) )
{
retval = FALSE;
}
else
{
if( x == 0 ) Lcd_CmdWrite( 0x80 + y );
else if( x==1 ) Lcd_CmdWrite( 0xC0 + y );
}
return retval;
}
void lcd_putchar( unsigned char c )
{
Lcd_DataWrite( c );
}
void lcd_putstring( char *string )
{
while(*string != '\0')
{
lcd_putchar( *string );
string++;
}
}
void lcd_putstring16( unsigned char line, char *string )
{
unsigned char len = 16;

lcd_gotoxy( line, 0 );
while(*string != '\0' && len--)
{
lcd_putchar( *string );
string++;
}
}
void init_lcd( void )
{
LcdDataDirn |= LCD_dataMask; // Configure all the LCD pins as output
LcdCtrlDirn |= LCD_ctrlMask;

// Initialize Lcd in 4-bit mode

Lcd_CmdWrite(0x03);
delay(2000);
Lcd_CmdWrite(0x03);
delay(1000);
Lcd_CmdWrite(0x03);
delay(100);
Lcd_CmdWrite(0x2);
Lcd_CmdWrite(0x28);
Lcd_CmdWrite(0x0e);
Lcd_CmdWrite(0x06);
Lcd_CmdWrite(0x01);
delay(1); // display on

pg. 22
Experiment No 7:-Using external interrupt switches toggle the led’s
Main code:-

#include <lpc17xx.h>

#define PINSEL_EINT1 22 // interrupt 1

#define PINSEL_EINT2 24 // interrupt 2

#define LED1 25 // led at p1.25

#define LED2 26 // led at p1.26

#define SBIT_EINT1 1 //extint bit 1

#define SBIT_EINT2 2 //extint bit 2

#define SBIT_EXTMODE1 1 //extint mode bit 1

#define SBIT_EXTMODE2 2 //extint mode bit 2

#define SBIT_EXTPOLAR1 1 //extint polarity mode bit 1

#define SBIT_EXTPOLAR2 2 //extint polarity mode bit 2

void EINT1_IRQHandler(void)
{
LPC_SC->EXTINT = (1<<SBIT_EINT1); /* Clear Interrupt Flag */
LPC_GPIO1->FIOPIN ^= (1<< LED1); /* Toggle the LED1 everytime INTR1 is generated */
}

void EINT2_IRQHandler(void)
{
LPC_SC->EXTINT = (1<<SBIT_EINT2); /* Clear Interrupt Flag */
LPC_GPIO1->FIOPIN ^= (1<< LED2); /* Toggle the LED2 everytime INTR2 is generated */
}

int main()
{
SystemInit();

LPC_SC->EXTINT = (1<<SBIT_EINT1) | (1<<SBIT_EINT2); /* Clear Pending interrupts */

LPC_PINCON->PINSEL4 = (1<<PINSEL_EINT1) | (1<<PINSEL_EINT2); /* Configure P2_11,P2_12 as EINT1/2 */
LPC_SC->EXTMODE = (1<<SBIT_EXTMODE1) | (1<<SBIT_EXTMODE2); /* Configure EINTx as Edge Triggered*/
LPC_SC->EXTPOLAR = (1<<SBIT_EXTPOLAR1)| (1<<SBIT_EXTPOLAR2); /* Configure EINTx as Falling Edge */

LPC_GPIO1->FIODIR = (1<<LED1) | (1<<LED2); /* Configure LED pins as OUTPUT */

LPC_GPIO1->FIOPIN = 0x00;

NVIC_EnableIRQ(EINT1_IRQn); /* Enable the EINT1,EINT2 interrupts */

NVIC_EnableIRQ(EINT2_IRQn);

while(1)
{
// Do nothing
}
}

pg. 23
Experiment No 8:-Display 0-F in 7 segment display
Main Code:-
#include <lpc17xx.h>

void delay_ms(unsigned int ms)

{
unsigned int i,j;

for(i=0;i<ms;i++)
for(j=0;j<40000;j++);
}

/* start the main program */

int main()
{
SystemInit(); //Clock and PLL configuration

LPC_GPIO0->FIODIR = 0x00000100; //Configure the PORT0 pins as OUTPUT;

LPC_GPIO1->FIODIR = 0x00004713;// all segment as output

while(1)
{

LPC_GPIO0->FIOSET = 0x00000100; // Make all the Port pins as high

LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments

LPC_GPIO1->FIOSET = 0x00004000;// set g to make 0
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00004701;//set a,d,e,f,g to make 1
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000410;//set c,f to make 2
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000600;//set e and f to make 3
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000301;//set a,d,e to make 4
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000202;//set b,e to make 5
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000002;//set b to make 6
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00004700;//set d,e,f,g to make 7
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000000;//set all 0 to make 8
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments

pg. 24
 LPC_GPIO1->FIOSET = 0x00000300;//set e to make 9
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000100;//set d to make A
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000003;//set a,b to make b
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00004012;//set set b,c,g to make C
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000401;//set a,f to make d
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000012;//set b,c to make E
delay_ms(200);
LPC_GPIO1->FIOCLR = 0x00004713;//clear all segments
LPC_GPIO1->FIOSET = 0x00000112;//set b,c,d to make F
delay_ms(200);

}
}

pg. 25
Experiment No 9:-Interface SPI ADC and display Ambient temperature
Main code:-

#include <LPC17xx.H>

#include <stdint.h>

#include <stdio.h>

#include "delay.h"

#include "spi_manul.h"

#include "lcd.h"

#define pulse_val 2

main()

unsigned int spi_rsv=0;

float vin;

char buf[20];

SystemInit ();

lcd_init();

lcd_str("SPI 3202-b");

delay(60000);

delay(60000);

while(1)

lcd_clr();

lcd_cmd(0x80);

spi_rsv = spi_data1(15);

vin = ( ( spi_rsv & 0xfff ) * (3.3) ) / 4096 ;

sprintf(buf,"Temp: %0.2f degC",(vin*100) );

lcd_str(buf);

delay(50000);

delay(50000);

pg. 26
 }

SPI ADC data fetching program:-

#include <LPC17xx.H>
#include "delay.h"
#define pulse_val 2
#define CLK 1<<27
#define CS 1<<28
#define DDOUT 26
#define DOUT 1<<25
#define DIN 1<<26
#define spi_stst 0
unsigned int spi_data(char sel)
{
char clks = 4;
LPC_GPIO0->FIODIR |= CS|CLK;
LPC_GPIO3->FIODIR = DOUT;

LPC_GPIO0->FIOSET = CS|CLK;
LPC_GPIO3->FIOCLR = DOUT;
nop_delay(100);
#if spi_stst
if ( LPC_GPIO3->FIOPIN & DIN )
{
return 'P';
}
#endif
LPC_GPIO0->FIOCLR = CS;
nop_delay(pulse_val);
while(clks)
{
LPC_GPIO0->FIOCLR = CLK;
nop_delay(pulse_val);

LPC_GPIO3->FIOPIN = (sel & 1) << DDOUT;

sel = sel >> 1;

LPC_GPIO0->FIOSET = CLK;
nop_delay(pulse_val);

clks--;
}
LPC_GPIO0->FIOCLR = CLK;
nop_delay(pulse_val);
if (!( LPC_GPIO3->FIOPIN & DIN ) )
{
return 'U';
}
clks = 12;
while(clks)
{
clks--;
LPC_GPIO0->FIOCLR = CLK;

pg. 27
 nop_delay(pulse_val);
LPC_GPIO0->FIOSET = CLK;
nop_delay(pulse_val);
}
nop_delay(pulse_val);
if (!( LPC_GPIO3->FIOPIN & DIN ) )
{
return 'U';
}
return 'Z';
}
unsigned int spi_data1(char sel)
{
unsigned int spi_reg=0;
char clks = 12;
LPC_GPIO0->FIODIR |= CS|CLK;
LPC_GPIO3->FIODIR = DOUT;

LPC_GPIO0->FIOSET = CS|CLK;
LPC_GPIO3->FIOSET = DOUT;
LPC_GPIO3->FIOPIN = DIN;

nop_delay(100);

LPC_GPIO0->FIOCLR = CS;
//start condi

LPC_GPIO0->FIOCLR = CLK;
LPC_GPIO3->FIOSET = DOUT;
nop_delay(pulse_val);
LPC_GPIO0->FIOSET = CLK;
nop_delay(5);

//single mode
LPC_GPIO0->FIOCLR = CLK;
LPC_GPIO3->FIOSET = DOUT;

nop_delay(pulse_val);
LPC_GPIO0->FIOSET = CLK;
nop_delay(5);
//chanl 1
LPC_GPIO0->FIOCLR = CLK;
LPC_GPIO3->FIOSET = DOUT;

nop_delay(pulse_val);
LPC_GPIO0->FIOSET = CLK;
nop_delay(5);
//msb first
LPC_GPIO0->FIOCLR = CLK;
LPC_GPIO3->FIOSET = DOUT;

nop_delay(pulse_val);
LPC_GPIO0->FIOSET = CLK;
nop_delay(5);
//smpling
// LPC_GPIO0->FIOCLR = CLK;
pg. 28
// nop_delay(pulse_val);
// LPC_GPIO0->FIOSET = CLK;
// nop_delay(2);

//null bit
LPC_GPIO0->FIOCLR = CLK;
nop_delay(pulse_val);
LPC_GPIO0->FIOSET = CLK;
// while ( ( LPC_GPIO3->FIOPIN & DIN ) == DIN );
// if( !( LPC_GPIO3->FIOPIN & DIN ) );
// {
// return 'U';
// }
nop_delay(5);
clks = 12;
while(clks)
{
LPC_GPIO0->FIOCLR = CLK;
nop_delay(pulse_val);
LPC_GPIO0->FIOSET = CLK;
if( ( LPC_GPIO3->FIOPIN & DIN ) )
{
spi_reg |= 1<<(clks-1);
}
else
{
spi_reg = spi_reg;
}
clks--;
nop_delay(5);
}
nop_delay(1);
return spi_reg;
}

LCD display program:-

#include <LPC17xx.H>
#include "delay.h"
#define RRW (7<<9)
#define DATA_L (15<<19)
void lcd_pin(void)
{
LPC_GPIO0->FIODIR |= RRW|DATA_L;
}

void lcd_cmd(unsigned char cmd)

{

LPC_GPIO0->FIOPIN =( ( ( cmd & 0xf0 )>> 4) << 19 )| (1<<11);

delay(200);
LPC_GPIO0->FIOPIN =( ( ( cmd & 0xf0 )>> 4) << 19 );

LPC_GPIO0->FIOCLR |= RRW|DATA_L;
delay(10);

pg. 29
 LPC_GPIO0->FIOPIN = ( ( ( cmd & 0xf ) ) << 19 )| (1<<11);
delay(200);
LPC_GPIO0->FIOPIN = ( ( ( cmd & 0xf ) ) << 19 );

void lcd_data(unsigned char cmd)

{
LPC_GPIO0->FIOPIN =(1<<9)|( ( ( cmd & 0xf0 )>> 4) << 19 )| (1<<11);
delay(200);
LPC_GPIO0->FIOPIN =( ( ( cmd & 0xf0 )>> 4) << 19 );

LPC_GPIO0->FIOCLR |= RRW|DATA_L;
delay(10);

LPC_GPIO0->FIOPIN = (1<<9)|( ( ( cmd & 0xf ) ) << 19 )| (1<<11);

delay(200);
LPC_GPIO0->FIOPIN = ( ( ( cmd & 0xf ) ) << 19 );
}
void lcd_init(void)
{
lcd_pin();
lcd_cmd(0x03);
delay(3000);
lcd_cmd(0x03);
delay(1000);
lcd_cmd(0x03);
delay(100);
lcd_cmd(0x2);
lcd_cmd(0x28);
lcd_cmd(0x0e);
lcd_cmd(0x06);
lcd_cmd(0x01);
delay(1);
}

void lcd_str(char *lstr)

{
while(*lstr)
{
lcd_data(*lstr);
lstr++;
}
}

void lcd_clr(void)
{
lcd_cmd(0x03);
delay(10);
lcd_cmd(0x2);
lcd_cmd(0x28);
lcd_cmd(0x0e);
lcd_cmd(0x06);
lcd_cmd(0x01);
delay(10);
}
pg. 30