Embedded Lab

EX.
NO: 1
STUDY OF ARM
DATE:
AIM:
APPARATUS REQUIRED:
THEORY:
The LPC2141/2/4/6/8 microcontrollers are based on a 32/16 bit ARM7TDMI-S
CPU with real-time emulation and embedded trace support, that combines the
microcontroller with embedded high speed flash memory ranging from 32 kB to 512 kB.
A 128-bit wide memory interface and a unique accelerator architecture enable 32-bit code
execution at the maximum clock rate. For critical code size applications, the alternative
16-bit Thumb mode reduces code by more than 30 % with minimal performance penalty.
Due to their tiny size and low power consumption, LPC2141/2/4/6/8 are ideal for
applications where miniaturization is a key requirement, such as access control and point-
of-sale. A blend of serial communications interfaces ranging from a USB 2.0 Full Speed
device, multiple UARTs, SPI, SSP to I2Cs, and on-chip SRAM of 8 kB up to 40 kB,
make these devices very well suited for communication gateways and protocol
converters, soft modems, voice recognition and low end imaging, providing both large
buffer size and high processing power. Various 32-bit timers, single or dual 10-bit
ADC(s), 10-bit DAC, PWM channels and 45 fast GPIO lines with up to nine edge or
level sensitive external interrupt pins make these microcontrollers particularly suitable for
industrial control and medical systems.
ARCHITECTURAL OVERVIEW
The LPC2141/2/4/6/8 consists of an ARM7TDMI-S CPU with emulation support,

the ARM7 Local Bus for interface to on-chip memory controllers, the AMBA Advanced
High-performance Bus (AHB) for interface to the interrupt controller, and the ARM
Peripheral Bus (APB, a compatible superset of ARM’s AMBA Advanced Peripheral Bus)
for connection to on-chip peripheral functions. The LPC2141/24/6/8 configures the
ARM7TDMI-S processor in little-endian byte order.
AHB peripherals are allocated a 2 megabyte range of addresses at the very top of
the 4 gigabyte ARM memory space. Each AHB peripheral is allocated a 16 kB address
space within the AHB address space. LPC2141/2/4/6/8 peripheral functions (other than
the interrupt controller) are connected to the APB bus. The AHB to APB bridge
interfaces the APB bus to the AHB bus. APB peripherals are also allocated a 2 megabyte
range of addresses, beginning at the 3.5 gigabyte address point. Each APB peripheral is
allocated a 16 kB address space within the APB address space.
The connection of on-chip peripherals to device pins is controlled by a Pin
Connect Block (see chapter "Pin Connect Block" on page 58). This must be configured
by software to fit specific application requirements for the use of peripheral functions and
pins.
ARM7TDMI-S PROCESSOR
The ARM7TDMI-S is a general purpose 32-bit microprocessor, which offers high
performance and very low power consumption. The ARM architecture is based on
Reduced Instruction Set Computer (RISC) principles, and the instruction set and related
decode mechanism are much simpler than those of microprogrammed Complex
Instruction Set Computers. This simplicity results in a high instruction throughput and
impressive real-time interrupt response from a small and cost-effective processor core.
Pipeline techniques are employed so that all parts of the processing and memory systems
can operate continuously. Typically, while one instruction is being executed, its successor
is being decoded, and a third instruction is being fetched from memory.
The ARM7TDMI-S processor also employs a unique architectural strategy known
as THUMB, which makes it ideally suited to high-volume applications with memory
restrictions, or applications where code density is an issue.
The key idea behind THUMB is that of a super-reduced instruction set.
Essentially, the ARM7TDMI-S processor has two instruction sets:
• The standard 32-bit ARM instruction set.
• A 16-bit THUMB instruction set.
The THUMB set’s 16-bit instruction length allows it to approach twice the
density of standard ARM code while retaining most of the ARM’s performance
advantage over a traditional 16-bit processor using 16-bit registers. This is possible
because THUMB code operates on the same 32-bit register set as ARM code.
THUMB code is able to provide up to 65% of the code size of ARM, and 160% of
the performance of an equivalent ARM processor connected to a 16-bit memory system.
The ARM7TDMI-S processor is described in detail in the ARM7TDMI-S Datasheet that
can be found on official ARM website
RESULT :
EX.NO: 2(a) ADC
DATE :
AIM :
APPARATUS REQUIRED:
PROGRAM:
#include <LPC214x.H>
#include <STRING.H>
void DELAY(unsigned int);

void INIT_GPIO(void);
void INIT_PLL(void);
void LCDSTR(unsigned char ADDRESS,char *MSG);
void LCD_DATA(unsigned char);
void LCD_CMD(unsigned int);
void LCD_INIT(void);
int READ_ADC(void);
void INIT_ADC(void);
void CONVERT_ADC(unsigned int);
unsigned int E = 0x00000800; // P1.21 ENABLE LCD

unsigned int RW = 0x00000400; // P1.22 READ/WRITE LCD
unsigned int RS = 0x00000200; // P1.23 REGISTER SELECT LCD
unsigned int TEMP=0,ADC=0;
int main()
INIT_PLL();
INIT_GPIO();
LCD_INIT();
INIT_ADC();
LCDSTR(0x00000080," ADC ");
LCDSTR(0x000000C0,"VOLTAGE = ");
while(1)
TEMP = READ_ADC();
ADC = 1000*(TEMP*(3.901/1024));
LCD_CMD(0x000000CA);
CONVERT_ADC(ADC);
void DELAY(unsigned int VALUE)
unsigned int i,j;

for(i=0;i<VALUE;i++)
for(j=1;j<1200;j++);
void INIT_GPIO()
{
IO0DIR =0x00000E00; // P0.8 ----- P0.15 LCD DATA
IO1DIR =0X00FF0000; // P1.21 --- P1.23 LCD CONTROL
void INIT_PLL()
{
PLL0CFG=0x00000024; // TO GENERATE 60 MHZ CCLK
PLL0CON=0x00000001;
PLL0FEED=0x000000AA; // UPDATE THE PLL REGISTER
PLL0FEED=0x00000055;
while(!(PLL0STAT & 0x00000400)); // CHECK WHETHRT THE CCLK IS

GENERATED EXAXT VALUE
PLL0CON=0x00000003; // CONNECT PLL
VPBDIV=0x00000002; // PCLK=1/2*CCLK
void LCD_DATA(unsigned char VALUE)
unsigned int b,TEMP;
TEMP = VALUE;
for(b=0;b<16;b++)
TEMP = TEMP<<1;
}
IO1SET = TEMP;
IO1CLR = ~TEMP;
IO0CLR = RW;
IO0SET = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
void LCD_CMD(unsigned int LCMD)
unsigned int b;
for(b=0;b<16;b++)
LCMD = LCMD<<1;
IO1SET = LCMD;
IO1CLR = ~LCMD;
IO0CLR = RW;
IO0CLR = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
void LCDSTR(unsigned char ADDRESS,char *MSG)
unsigned char COUNT,LENGTH;
LCD_CMD(ADDRESS);
LENGTH = strlen(MSG);
for(COUNT=0;COUNT<LENGTH;COUNT++)
LCD_DATA(*MSG);
MSG++;
void LCD_INIT()
{
LCD_CMD(0x00000038);
LCD_CMD(0x0000000C);
LCD_CMD(0x00000001);
LCD_CMD(0x00000006);
}
void INIT_ADC()
PINSEL1 |= 0x01000000;
AD0CR = 0x00200602;
int READ_ADC()
{
int VAL;
AD0CR |= 0x01000000; /* Start A/D Conversion */
do
VAL = AD0DR1; /* Read A/D Data Register */
while (!(VAL & 0x80000000)); /* Wait for end of A/D

Conversion */
AD0CR &= ~0x01000000; /* Stop A/D Conversion */
VAL >>=6;
VAL = VAL & 0x3FF;
return(VAL);
void CONVERT_ADC(unsigned int ADC)
unsigned int CNT1,CNT2,CNT3,CNT4;
unsigned char DATA1,DATA2,DATA3,DATA4;
CNT1 = ADC % 10000/1000;
CNT2 = ADC % 1000/100;
CNT3 = ADC % 100/10;
CNT4 = ADC % 10/1;
DATA1 = CNT1 | 0x30;

LCD_DATA(DATA1);
LCD_DATA('.');
LCD_DATA(DATA2);
LCD_DATA(DATA3);
LCD_DATA(DATA4);
return;
RESULT:
EX.NO: 2(b) DAC
DATE :
AIM :
APPARATUS REQUIRED:
PROGRAM:
#include<lpc214x.h>
#include"math.h"
unsigned int t;
void Delay(unsigned long b)
while (--b!=0);
int main()
int value=0x3ff;
PINSEL1 = 0X00080000;
while(1)
{
value = 512+400*sin(t*0.01745);
DACR = value<<6;
if(++t==360)t=0;
}
}
RESULT
EX. NO: 3 PWM
DATE:
AIM :
APPARATUS REQUIRED:
PROGRAM:
#include<LPC214x.h>
/*
************************************************************************
**********************
* Function : PwmInit
* Description : Routine for 120 Khz Frequency Generation
* Parameters : None
************************************************************************
**********************
*/
int READ_ADC(void);
unsigned int PWM=0;
void PwmInit()
{
PINSEL0 = 0X00008000; // Enable PWM2 -- P0.7
PWMLER = 0X00000004; // Set latch register
PWMPR = 0X00000000; // Prescale 0
PWMMR0 = 0X000003FF; // 120 KHz Frequency
PWMMR2 = 0X000003FF; // 50% Duty Cycle 7C 0,62,124,186
PWMMCR = 0X00000002; // Set only Match0 control
PWMPCR = 0X00000400;
PWMTCR = 0X00000009;
}
int main()
{
PwmInit();
INIT_ADC();
//IO0DIR = 0x000000FF;
//IO0CLR &= 0x000000FF;
while(1)
{
PWM = READ_ADC();
if(PWM>0x000003FF) PWM=0x000003FF;
PWMMR2 = PWM;
PWMTCR = 0X00000000;
PWMTCR = 0X00000009;
}
}
void INIT_ADC()
{
PINSEL1 |= 0x01000000;
AD0CR = 0x00200602;
}
int READ_ADC()
{
int VAL;
do
{
}
Conversion */
VAL >>=6;
VAL = VAL & 0x3FF;
return(VAL);
}
RESULT:
EX. NO: 4(a) RTC
DATE:
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include <STRING.H>

void SETTIME(void);

void SETTIME(void)
{
CCR = 0x02;
HOUR = 0;
MIN = 0;
SEC = 0;
CCR = 0x11;
}
int main()
{
SETTIME();
INIT_GPIO();
LCD_INIT();
LCDSTR(0x00000080,"REAL TIME CLOCK ");
LCDSTR(0x000000C0," ");
while(1)
{
LCD_CMD (0x000000C3);
LCD_DATA(HOUR/10 + '0');
LCD_DATA(HOUR%10 + '0');
LCD_DATA(':') ;
LCD_DATA(MIN/10 + '0');
LCD_DATA(MIN%10 + '0');
LCD_DATA(':') ;
LCD_DATA(SEC/10 + '0');
LCD_DATA(SEC%10 + '0');
}
}
{
unsigned int i,j;
{
for(j=1;j<1200;j++);
}
}
void INIT_GPIO()
{
}
{
TEMP = VALUE;
for(b=0;b<16;b++)
{
TEMP = TEMP<<1;
}
IO1SET = TEMP;
IO1CLR = ~TEMP;
IO0CLR = RW;
IO0SET = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
unsigned int b;
for(b=0;b<16;b++)
{
LCMD = LCMD<<1;
}
IO1SET = LCMD;
IO1CLR = ~LCMD;
IO0CLR = RW;
IO0CLR = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
LCD_CMD(ADDRESS);
{
LCD_DATA(*MSG);
MSG++;
}
}
void LCD_INIT()
{
LCD_CMD(0x00000038);
LCD_CMD(0x00000001);
LCD_CMD(0x00000006);
}
RESULT:
EX. NO: 4(b) SERIAL PORT
DATE:
AIM:
APPARATUS REQUIRED :
PROGRAM:
#include <LPC214x.H> /* LPC21xx definitions*/
#include "SERIAL.H"
int main(void)
{
int j=0;
init_serial (); /* initialise serial port with
9600bps*/
sendchar ('A'); /* transmit char A */
j=50;
while(j++ < 1000);
while(1)
{
sendchar (getchar()); /* receive and
transmit char*/
}
}
RESULT:
EX. NO: 5(a) HEX KEY WITH LCD
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include <STRING.H>
#define O1 0X00E00000
#define O2 0X00D00000
#define O3 0X00B00000
#define O4 0X00700000
#define I1 0x000E0000
#define I2 0x000D0000
#define I3 0x000B0000
#define I4 0x00070000
#define CLR 0x00F00000

void LCD_CD(unsigned int);
char scan (int);
void delay(int);

int main()
{
INIT_PLL();
INIT_GPIO();
LCD_INIT();
LCDSTR(0x00000080,"Matrix KeyPad ");
LCDSTR(0x000000C0,"Key Pressed: ");
while(1)
{
IO0CLR = CLR;
IO0SET = O1;
delay(10);
if(scan(I1))LCDSTR(0x000000CC,"0"); //S1
if(scan(I4))LCDSTR(0x000000CC,"C"); //S13
IO0CLR = CLR;
IO0SET = O2;
if(scan(I4))LCDSTR(0x000000CC,"D"); //S14
IO0CLR = CLR;
IO0SET = O3;
if(scan(I3))LCDSTR(0x000000CC,"A"); //S11
if(scan(I4))LCDSTR(0x000000CC,"E"); //S15
IO0CLR = CLR;
IO0SET = O4;
if(scan(I3))LCDSTR(0x000000CC,"B"); //S12
if(scan(I4))LCDSTR(0x000000CC,"F"); //S16
}
}
char scan(int keystatus) /* scanning a a key */
{
while((IO0PIN & 0X000F0000)==keystatus)
{
delay(50);
if((IO0PIN & 0X000F0000)== 0X000F0000)return(1);
}
return(0) ;
}
void delay(int n) /* generates one milisecond delay */

{
int i,j;
for (i=1; i<=n; i++)
for(j=0; j<=10000; j++);
}
{
unsigned int i,j;
{
for(j=1;j<1200;j++);
}
}
void INIT_GPIO()
{
IO0DIR =0x00F00E00; // P0.8 ----- P0.15 LCD DATA
}
void INIT_PLL()
{
PLL0CON=0x00000001;
}
{
TEMP = VALUE;
for(b=0;b<16;b++)
{
TEMP = TEMP<<1;
}
IO1SET = TEMP;
IO1CLR = ~TEMP;
IO0CLR = RW;
IO0SET = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
unsigned int b;
for(b=0;b<16;b++)
{
LCMD = LCMD<<1;
}
IO1SET = LCMD;
IO1CLR = ~LCMD;
IO0CLR = RW;
IO0CLR = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
LCD_CMD(ADDRESS);
{
LCD_DATA(*MSG);
MSG++;
}
}
void LCD_INIT()
{
LCD_CMD(0x00000038);
LCD_CMD(0x00000001);
LCD_CMD(0x00000006);
}
RESULT:
EX. NO: 5(b) To display a message on LCD
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include <STRING.H>


int main()
{
INIT_PLL();
INIT_GPIO();
LCD_INIT();
while(1)
{
LCDSTR(0x00000080,"*ChipMax Design-");
LCDSTR(0x000000C0,"*Labs- BANGALORE");
}
}
{
unsigned int i,j;
{
for(j=1;j<1200;j++);
}
}
void INIT_GPIO()
{
IO0DIR =0x0000FF00; // P0.8 ----- P0.15 LCD DATA
IO1DIR =0X00F00000; // P1.21 --- P1.23 LCD CONTROL
}
void INIT_PLL()
{
PLL0CON=0x00000001;

}
{
TEMP = VALUE;
for(b=0;b<8;b++)
{
TEMP = TEMP<<1;
}
IO0SET = TEMP;
IO0CLR = ~TEMP;
IO1CLR = RW;
IO1SET = RS;
IO1SET = E;
DELAY(50);
IO1CLR = E;
}
{
unsigned int b;
for(b=0;b<8;b++)
{
LCMD = LCMD<<1;
}
IO0SET = LCMD;
IO0CLR = ~LCMD;
IO1CLR = RW;
IO1CLR = RS;
IO1SET = E;
DELAY(50);
IO1CLR = E;
}
{
LCD_CMD(ADDRESS);
{
LCD_DATA(*MSG);
MSG++;
}
}
void LCD_INIT()
{
LCD_CMD(0x00000038);
//DELAY(400);
//DELAY(400);
LCD_CMD(0x00000001);
//DELAY(400);
LCD_CMD(0x00000006);
//DELAY(400);
}
RESULT:
EX.NO: 6(a) EXTERNAL EEPROM
DATE:
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include <LPC21xx.H>
#include <STRING.H>
#define DEV_WR_STAT 0X18

#define DEV_RD_STAT 0X40
#define LOC_WR_STAT 0x28
#define DATA_WR_STAT 0x28
#define DEV_WRITE 0XA0
#define DEV_READ 0XA1
#define O4 0X00700000
#define I4 0x00070000

void delay(unsigned int del);
void i2c_init(void);
void i2c_start(void);
void i2c_write(char dat , char status);
void i2c_stop(void);
char i2c_read(void);
void eeprom_read(char loc,char loc_count , char *ptr);
void eeprom_write(char loc , char *ptr);
char scan (int);
void delay1(int);

unsigned char I2Cdata;
char buf[16];
unsigned char cnt=0;
int main()
{
INIT_GPIO();
LCD_INIT();
LCDSTR(0x00000080,"Ext EEPROM TEST ");
LCDSTR(0x000000C0,"MESSAGE COUNT: 1");
cnt=1;
while(1)
{
IO0CLR = CLR;
IO0SET = O1;
delay(10);
if(scan(I1))
{
cnt=1;
}
if(scan(I2))
{
if(cnt==1)
{
eeprom_write(0 , "Enthu Technology");
LCDSTR(0x000000C0,"Writting ");
delay(120000);
}
if(cnt==2)
{
eeprom_write(0 , "Coimbatore ");
delay(120000);
}
if(cnt==3)
{
eeprom_write(0 , "SSN Sqaure ");
delay(120000);
}
if(cnt==4)
{
eeprom_write(0 , "Tamil Nadu ");
delay(120000);
}
}
IO0CLR = CLR;
IO0SET = O2;
if(scan(I1))
{
cnt=2;
}
if(scan(I2))
{
eeprom_read(0,16, buf);
LCDSTR(0x000000C0,"Reading ");
DELAY(5000);
LCDSTR(0xC0,buf);
}
IO0CLR = CLR;
IO0SET = O3;
if(scan(I1))
{
cnt=3;
}
if(scan(I2))
{
eeprom_write(0 , " ");
LCDSTR(0x000000C0,"Erasing ");
delay(120000);
cnt=5;
}
IO0CLR = CLR;
IO0SET = O4;
if(scan(I1))
{
cnt=4;
}
}
}
{
unsigned int i,j;
{
for(j=1;j<1200;j++);
}
}
void INIT_GPIO()
{
}
{
TEMP = VALUE;
for(b=0;b<16;b++;
{
TEMP = TEMP<<1;
}
IO1SET = TEMP;
IO1CLR = ~TEMP;
IO0CLR = RW;
IO0SET = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
unsigned int b;
for(b=0;b<16;b++)
{
LCMD = LCMD<<1;
}
IO1SET = LCMD;
IO1CLR = ~LCMD;
IO0CLR = RW;
IO0CLR = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
LCD_CMD(ADDRESS);
{
LCD_DATA(*MSG);
MSG++;
}
}
void LCD_INIT()
{
LCD_CMD(0x00000038);
LCD_CMD(0x00000001);
LCD_CMD(0x00000006);
}
void delay(unsigned int del)
{
while(del-- > 0);
}
void i2c_init(void)
{
PINSEL0 = 0X50;
I2CONCLR = 0X0000002C; /* clears AA,I2C
interrupt flag,START flag bit*/
I2CONSET = 0X00000044; /* enable i2c */
I2SCLL = 0xFFFF; /* bitrate = 400kHz */ // 70,5
I2SCLH = 0xFFFF;;
}
void i2c_start()
{
I2CONSET |= 0x00000020; /* Set STA flag */
while (I2STAT != 0x00000008); /* Wait for Status Set - 0x08 */
}
void i2c_write(char dat , char status)
{
I2DAT = dat;
I2CONSET = 0X00000004;
I2CONCLR = 0X00000028;
while (I2STAT != status); /* Wait for Status Set */
}
void i2c_stop(void)
{
I2CONSET |= 0x00000014;
I2CONCLR = 0x00000008; /* Stop I2C and Start Bit */
}
char i2c_read(void)
{
I2CONSET = 0X00000004;
I2CONCLR = 0X00000028;
while (I2STAT != 0x00000050); /* Wait for Status Set - 0x50 */

return(I2DAT);
}
void eeprom_read(char loc,char loc_count , char *ptr)
{
i2c_init();
i2c_start();
i2c_write(DEV_WRITE ,DEV_WR_STAT);
i2c_write(loc , LOC_WR_STAT);
i2c_stop();
delay(5000);
i2c_start();
i2c_write(DEV_READ ,DEV_RD_STAT);
while(loc_count-- > 0)
{
*ptr = i2c_read();
ptr++;
}
i2c_stop();
}
void eeprom_write(char loc , char *ptr)
{
i2c_init();
i2c_start();
i2c_write(DEV_WRITE ,DEV_WR_STAT);
i2c_write(loc , LOC_WR_STAT);
while(*ptr != '\0')
{
i2c_write(*ptr , LOC_WR_STAT);
ptr++;
}
i2c_stop();
}

{
while((IO0PIN & 0X000F0000)==keystatus){
delay1(50);
if((IO0PIN & 0X000F0000)== 0X000F0000)return(1);
}
return(0) ;
}
void delay1(int n) /* generates one milisecond delay */
{
int i,j;
for (i=1; i<=n; i++)
for(j=0; j<=10000; j++);
}
RESULT:
EX. NO: 6(b) EXTERNAL INTERRUPT
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include<lpc21xx.h>
void DELAY(unsigned long VALUE);
unsigned int A = 0x00010000;
void ext_interrupt(void)__irq
{
EXTINT = 0X02; /* Clear interrupt flag
*/
DELAY(5000000);
VICVectAddr = 0x00000000; /*
Acknowledge Interrupt */
}
void init_ext(void)
{
PINSEL0 |= 0X20000000; /* enable
EXT1 */
EXTMODE = 0X02; /*
edge sensitive */
EXTPOLAR = 0X02; /*
on rising edge */
VICVectAddr0 =(unsigned int)ext_interrupt; /* Set Interrupt Vector in 0 */
VICVectCntl0 = 0x0000002F; /* Use it for
EXT1 Interrupt */
VICIntEnable = 0x00008000; /* enable
EXT1 INTERRUPT */
}
int main(void)
{
IO0DIR = 0X00FF0000;
init_ext();
while(1)
{
IO0SET |= A; /* Port0 00-07 High */
DELAY(1000000);
IO0CLR |= A; /* Port0 00-07 High */
A <<=1;
if(A==0x01000000) A=0x00010000;
DELAY(1000000);
}
}
void DELAY(unsigned long VALUE)
{
while(VALUE>0)
{
VALUE--;
}
}
RESULT :
EX.NO: 7 Mailbox
DATE :
AIM :
APPARATUS REQUIRED:
PROGRAM :
#include <RTL.h>
#include <stdio.h>
OS_TID tsk1;
OS_TID tsk2;
typedef struct
{
float voltage;
float current;
U32 counter;
}T_MEAS;
os_mbx_declare (MsgBox,16);
_declare_box (mpool,sizeof(T_MEAS),16);
__task void send_task (void);

__task void rec_task (void);
void init_serial ()
{
PINSEL0 = PINSEL0 | 0X00000005;
U0LCR = 0X83;
U0DLL = 0Xbb;
U0DLM = 0X00;
U0LCR = 0X03;
}
__task void send_task (void)

{
T_MEAS *mptr;
tsk1 = os_tsk_self ();
tsk2 = os_tsk_create (rec_task, 0);
os_mbx_init (MsgBox, sizeof(MsgBox));
os_dly_wait (5);
mptr = _alloc_box (mpool);

mptr->voltage = 223.72;
mptr->current = 17.54;
mptr->counter = 120786;
os_mbx_send (MsgBox, mptr, 0xffff);
IOSET0 = 0x00010000;
os_dly_wait (100);

os_tsk_pass ();
IOSET0 = 0x00020000;
os_dly_wait (100);

IOSET0 = 0x00040000;
os_dly_wait (100);
os_tsk_delete_self ();
}
__task void rec_task (void)

{
T_MEAS *rptr;
for (;;)
{
os_mbx_wait (MsgBox, (void **)&rptr, 0xffff);
printf ("\nVoltage: %.2f V\n",rptr->voltage);
printf ("Current: %.2f A\n",rptr->current);
printf ("Number of cycles: %d\n",rptr->counter);
_free_box (mpool, rptr);
}
}
int main (void)

{
IODIR0 = 0x00FF0000;
IOCLR0 = 0x00FF0000;
init_serial ();
_init_box (mpool, sizeof(mpool),sizeof(T_MEAS));
os_sys_init (send_task);
}
RESULT :
EX.NO : 8 LED BLINK
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include <LPC214X.H>
void DELAY(unsigned long VALUE);
unsigned char A = 0x01;
int main()
{
IO0DIR = 0x000000FF; /* Port0 00-07 as output*/
while(1) /* Infinite loop*/
{
IO0SET |= A; /* Port0 00-07 High */
DELAY(1000000);
IO0CLR |= A; /* Port0 00-07 High */
A <<=1;
if(A==0x00) A=0x01;
DELAY(1000000);
}
}
void DELAY(unsigned long VALUE)
{
while(VALUE>0)
{
VALUE--;
}
}
RESULT :
EX. NO :9(a) STEPPER MOTOR
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include<LPC214X.H>
#define O4 0X00000070
#define I1 0x0000000E
#define I2 0x0000000D
#define I3 0x0000000B
#define I4 0x00000007
unsigned int CLOCK[4] = {0x00330000,0x00990000,0x00CC0000,0x00660000};

unsigned int ANTI_CLOCK[4] = {0x00660000,0x00CC0000,0x00990000,0x00330000};
char scan (int);

void delay(int);
int main(void){
IO0DIR = 0X00FF00F0;
while(1){
unsigned char I;
IO0CLR = CLR;
IO0SET = O1;
while(scan(I1)) //S1
{
for(I=0;I<4;I++)
{
IO0SET |= CLOCK[I];
IO0CLR |= ~CLOCK[I];
delay(5);
}
}
{
for(I=0;I<4;I++)
{
IO0SET |= CLOCK[I];
delay(10);
}
}
IO0CLR = CLR;
IO0SET = O2;
{
for(I=0;I<4;I++)
{
IO0SET |= ANTI_CLOCK[I];
IO0CLR |= ~ANTI_CLOCK[I];
delay(5);
}
}
{
for(I=0;I<4;I++)
{
IO0SET |= CLOCK[I];
delay(50);
}
}
IO0CLR = CLR;
IO0SET = O4;
{
for(I=0;I<4;I++)
{
IO0SET |= CLOCK[I];
delay(90);
}
}
}
}

{
while((IO0PIN & 0X0000000F)==keystatus)
{
return(1);
}
return(0);
}
{
int i,j;
for (i=1; i<=n; i++)
for(j=0; j<=10000; j++);
}
RESULT :
EX. NO: 9(b) Temperature Sensor
DATE :
AIM :
APPARATUS REQUIRED:
PROGRAME:
#include <STRING.H>

int READ_ADC(void);
void CONVERT_ADC(unsigned int);

unsigned int TEMP=0,ADC=0;

int main()
{
INIT_PLL();
INIT_GPIO();
LCD_INIT();
INIT_ADC();
LCDSTR(0x00000080," TEMPERATURE ");
LCDSTR(0x000000C0,"DEGREE C = ");
while(1)
{
TEMP = READ_ADC();
ADC = (1000*(TEMP*(3.901/1024)))-100;
LCD_CMD(0x000000CA);
CONVERT_ADC(ADC);
}
}
{
unsigned int i,j;
{
for(j=1;j<1200;j++);
}
}
void INIT_GPIO()
{
}
void INIT_PLL()
{
PLL0CON=0x00000001;

}
{
TEMP = VALUE;
for(b=0;b<16;b++)
{
TEMP = TEMP<<1;
}
IO1SET = TEMP;
IO1CLR = ~TEMP;
IO0CLR = RW;
IO0SET = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
unsigned int b;
for(b=0;b<16;b++)
{
LCMD = LCMD<<1;
}
IO1SET = LCMD;
IO1CLR = ~LCMD;
IO0CLR = RW;
IO0CLR = RS;
IO0SET = E
DELAY(50);
IO0CLR = E;
}
{
LCD_CMD(ADDRESS);
{
LCD_DATA(*MSG);
MSG++;
}
}
void LCD_INIT()
{
LCD_CMD(0x00000038);
LCD_CMD(0x00000001);
LCD_CMD(0x00000006);
}
void INIT_ADC()
{
PINSEL1 |= 0x01000000;
AD0CR = 0x00200602;
}
int READ_ADC()
{
int VAL;
do
{
}
Conversion */
VAL >>=6;
VAL = VAL & 0x3FF;
return(VAL);
}
void CONVERT_ADC(unsigned int ADC)
{
unsigned int CNT1,CNT2,CNT3,CNT4;
unsigned char DATA1,DATA2,DATA3,DATA4;
CNT1 = ADC % 10000/1000;
CNT2 = ADC % 1000/100;
CNT3 = ADC % 100/10;
CNT4 = ADC % 10/1;
LCD_DATA(DATA1);
LCD_DATA(DATA2);
LCD_DATA(DATA3);
LCD_DATA('.');
LCD_DATA(DATA4);
return;
}
RESULT:
EX.NO: 10(a) ZIGBEE NODE A
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include <STRING.H>
#define O4 0X00700000
#define I4 0x00070000

char sendchar (char SDat);
void init_serial (void);
char scan (int);
char scan(int keystatus);

int main()
{
init_serial();
INIT_PLL();
INIT_GPIO();
LCD_INIT();
LCDSTR(0x00000080," Zig Bee Based ");
LCDSTR(0x000000C0,"Motor Controller");
DELAY(6000);
while(1)
{
IO0CLR = CLR;
IO0SET = O1;
while(scan(I1))
{
LCDSTR(0x000000C0,"Running C-wise ");
sendchar('C');
}
IO0CLR = CLR;
IO0SET = O2;
while(scan(I1))
{
LCDSTR(0x000000C0,"Running AC-wise ");
sendchar('A');
}
LCDSTR(0x000000C0,"Motor Stopped ");
}
}
{
unsigned int i,j;
{
for(j=1;j<1200;j++);
}
}
void INIT_GPIO()
{
}
void INIT_PLL()
{
PLL0CON=0x00000001;
}
{
TEMP = VALUE;
for(b=0;b<16;b++)
{
TEMP = TEMP<<1;
}
IO1SET = TEMP;
IO1CLR = ~TEMP;
IO0CLR = RW;
IO0SET = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
unsigned int b;
for(b=0;b<16;b++)
{
LCMD = LCMD<<1;
}
IO1SET = LCMD;
IO1CLR = ~LCMD;
IO0CLR = RW;
IO0CLR = RS;
IO0SET = E;
DELAY(50);
IO0CLR = E;
}
{
LCD_CMD(ADDRESS);
{
LCD_DATA(*MSG);
MSG++;
}
}
void LCD_INIT()
{
LCD_CMD(0x00000038);
LCD_CMD(0x00000001);
LCD_CMD(0x00000006);
}
void init_serial (void)
{
PINSEL0 = PINSEL0 | 0X00000005;
U0LCR = 0X83;
U0DLL = 0XC3;
U0DLM = 0X00;
U0LCR = 0X03;
}
char sendchar (char SDat)

{
while (!(U0LSR & 0x20));
return (U0THR = SDat);
}
char scan(int keystatus)
{
{
return(1);
}
return(0);
}
RESULT:
EX. NO: 10(b) ZIGBEE NODE B
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM:
#include "serial.h"
void delay(int n);
unsigned int CLOCK[4] = {0x00330000,0x00990000,0x00CC0000,0x00660000};

unsigned int ANTI_CLOCK[4] = {0x00660000,0x00CC0000,0x00990000,0x00330000};
unsigned char SBUF=0;
int main(void)
{
init_serial ();
IO0DIR = 0X00FF0000;
while(1)
{
SBUF= getchar();
if(SBUF=='C')
{
IO0SET |= CLOCK[0];
IO0CLR |= ~CLOCK[0];
delay(5);
IO0SET |= CLOCK[1];
delay(5);
IO0SET |= CLOCK[2];
delay(5);
IO0SET |= CLOCK[3];
delay(5);
}
if(SBUF=='A')
{
IO0SET |= ANTI_CLOCK[0];
IO0CLR |= ~ANTI_CLOCK[0];
delay(5);
delay(5);
delay(5);
delay(5);
}
}
}
void delay(int n)
{
int i,j;
for (i=1; i<=n; i++)
for(j=0; j<=10000; j++);
}
///// ----------------
RESULT:
EX.NO: 11 DC MOTOR
DATE :
AIM:
APPARATUS REQUIRED:
PROGRAM :
#include<LPC214X.H>
#define O4 0X00700000
#define I4 0x00070000
unsigned int PWM1 = 0x00000001; // P1.21 PWM1

unsigned int PWM2 = 0x00000008; // P1.22 PWM2
unsigned int ENBL = 0x00000002; // P1.23 ENABLE
char scan (int);

void delay(int);
int main(void){
IO0DIR = 0X00F00083;
while(1){
IO0SET |= ENBL;
IO0CLR = CLR;
IO0SET = O1;
{
IO0SET |= PWM1;
IO0CLR |= PWM2;
}
{
IO0CLR |= PWM2;
IO0SET |= PWM1;
delay(30);
IO0CLR |= PWM1;
delay(10);
}
IO0CLR = CLR;
IO0SET = O2;
{
IO0SET |= PWM2;
IO0CLR |= PWM1;
}
{
IO0CLR |= PWM2;
IO0SET |= PWM1;
delay(15);
IO0CLR |= PWM1;
delay(15);
}
IO0CLR = CLR;
IO0SET = O3;
{
IO0CLR |= PWM2;
IO0SET |= PWM1;
delay(10);
IO0CLR |= PWM1;
delay(30);
}
}
}
{
{
return(1);
}
return(0);
}
{
int i,j;
for (i=1; i<=n; i++)
for(j=0; j<=10000; j++);
}
RESULT:

Embedded Lab

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Embedded Lab

Uploaded by

Copyright:

Available Formats

EX.

The LPC2141/2/4/6/8 consists of an ARM7TDMI-S CPU with emulation support,

void DELAY(unsigned int);

unsigned int E = 0x00000800; // P1.21 ENABLE LCD

unsigned int RS = 0x00000200; // P1.23 REGISTER SELECT LCD

unsigned int TEMP=0,ADC=0;

LCDSTR(0x00000080," ADC ");

void DELAY(unsigned int VALUE)

unsigned int i,j;

while(!(PLL0STAT & 0x00000400)); // CHECK WHETHRT THE CCLK IS

void LCD_DATA(unsigned char VALUE)

unsigned int b,TEMP;

void LCD_CMD(unsigned int LCMD)

void LCDSTR(unsigned char ADDRESS,char *MSG)

unsigned char COUNT,LENGTH;

AD0CR |= 0x01000000; /* Start A/D Conversion */

VAL = AD0DR1; /* Read A/D Data Register */

while (!(VAL & 0x80000000)); /* Wait for end of A/D

AD0CR &= ~0x01000000; /* Stop A/D Conversion */

VAL = VAL & 0x3FF;

void CONVERT_ADC(unsigned int ADC)

unsigned int CNT1,CNT2,CNT3,CNT4;

unsigned char DATA1,DATA2,DATA3,DATA4;

CNT1 = ADC % 10000/1000;

CNT2 = ADC % 1000/100;

CNT3 = ADC % 100/10;

CNT4 = ADC % 10/1;

DATA1 = CNT1 | 0x30;

DATA2 = CNT2 | 0x30;

DATA3 = CNT3 | 0x30;

void Delay(unsigned long b)

void DELAY(unsigned int);

unsigned int E = 0x00000800; // P1.21 ENABLE LCD

void DELAY(unsigned int);

unsigned int E = 0x00000800; // P1.21 ENABLE LCD

void delay(int n) /* generates one milisecond delay */

void DELAY(unsigned int);

unsigned int E = 0x00800000; // P1.21 ENABLE LCD

while(!(PLL0STAT & 0x00000400)); // CHECK WHETHRT THE CCLK IS

#define DEV_WR_STAT 0X18

void DELAY(unsigned int);

unsigned int E = 0x00000800; // P1.21 ENABLE LCD

while (I2STAT != 0x00000050); /* Wait for Status Set - 0x50 */

char scan(int keystatus) /* scanning a a key */

__task void send_task (void);

__task void send_task (void)

mptr = _alloc_box (mpool);

mptr = _alloc_box (mpool);

mptr = _alloc_box (mpool);

__task void rec_task (void)

int main (void)

#define CLR 0x000000F0

unsigned int CLOCK[4] = {0x00330000,0x00990000,0x00CC0000,0x00660000};

char scan (int);

char scan(int keystatus) /* scanning a a key */

void DELAY(unsigned int);

unsigned int E = 0x00000800; // P1.21 ENABLE LCD

unsigned int TEMP=0,ADC=0;

PLL0CON=0x00000003; // CONNECT PLL

#define CLR 0x00F00000

void DELAY(unsigned int);

unsigned int E = 0x00000800; // P1.21 ENABLE LCD

void init_serial (void)

char sendchar (char SDat)