PWM programming in ARM

  #include<lpc21xx.h>
  int main()
  {

    PINSEL0=0x00008000;
 
    PWMMR0=100;

    PWMMR1=41;

    PWMMR2=78;

    PWMTCR=0x00000009;

   PWMPR=0X00000000;

   PWMTC=0X00000000;

   PWMMCR=0X00000002;

   PWMPCR=0X0604;
   //PWMLER=1;

   while(1);
  }

TIMER0 MATCH INTERRUPT OF LPC2129/38(ARM7)

  #include<lpc21xx.h>
  void delay();
  __irq void timerint();
  int main()
  {
  IO0DIR=0XFFFFFFFF;
   T0TCR=1;
 
   T0TC=0X00000000;
  T0PR=1;
  T0MCR=0X003;
  T0MR0=0X0F00FFF;
   VICVectCntl0=0x24;
 
   VICIntEnable=0x00000010;
   VICVectAddr0=(unsigned)timerint;
  while(1);
 
  }
  __irq void timerint()
  {
 
  // T0TC=0X00000000;
  IO0SET=0XFFFFFFFF;
  delay();
  IO0CLR=0XFFFFFFFF;
  delay();
  T0IR=0X01;
  VICVectAddr=0;
  }
  void delay()
  {
  int i;
  for(i=0;i<100000;i++);
  }

TIMER0 CAPTURE INTERRUPT OF LPC2129/38(ARM7)

#include<lpc21xx.h>

void delay();
__irq void capint();
int main()
{
PINSEL0=0X00000020;
IO1DIR=0XFFFFFFFF;
T0TCR=1;
 T0CCR=0X05;
T0TC=0X00000000;

VICVectCntl0=0x24;
VICIntEnable=0x00000010;
VICVectAddr0=(unsigned)capint;
while(1);

}

__irq void capint()
{
IO1SET=0XFFFFFFFF;
delay();
IO1CLR=0XFFFFFFFF;
delay();
T0IR=0X10;
VICVectAddr=0;
}

void delay()
{
int i;
for(i=0;i<10000000;i++);
}

UART INTERRUPT OF LPC2129/38(ARM7)

#include<lpc21xx.h>

__irq void uartint(void);
void delay(void);
int main()
{IO1DIR=0XFFFFFFFF;
PINSEL0=0X00000004;
U0LCR=0X83;
U0DLM=0X00;
U0DLL=0X51;
U0LCR=0X03;
U0IER=0X01;

VICVectAddr0=(unsigned)uartint;
 VICIntSelect=0x00000000;
VICIntEnable=0x00000040;
VICVectCntl0=0x00000026;

  while(1)
  {
   delay();
  }
  }
 __irq void uartint()
 {
   U0IIR=0X04;
  IO1SET=0XFFFFFFFF;
  delay();
  IO1CLR=0XFFFFFFFF;
  delay();
  //U0IER=0X01;
  
   VICVectAddr=0;
  }
  void delay()
  {
  int i;
  for(i=0;i<1000000;i++);
  }

EXTERNAL INTERRUPT PROGRAMMING OF LPC2129/38(ARM7)

#include<lpc21xx.h>
void delay();
__irq void extint();
int main()
{
 IO0DIR=0;
IO1DIR=0XFFFFFFFF;
PINSEL0=0X0000000C;
//PINSEL1=0X00000001;
//EXTINT=0X0;
//EXTMODE=0X00;
//EXTPOLAR=0X01;
VICVectCntl0=0x0000002E;
  VICVectAddr0=(unsigned)extint;
 //VICIntSelect=0x00000000;
VICIntEnable=0x00004000;
EXTINT=0X01;

while(1)
{ //EXTINT=0X01;
delay();
}

}
void extint()__irq
{

IO1CLR=0XFFFFFFFF;
delay();
IO1SET=0XFFFFFFFF;
delay();
  VICVectAddr=0;


}
void delay()
{
int i,j;
//for(j=0;j<k;j++)
for(i=0;i<10000;i++);
}

LPC2129/38(ARM7) INTERRUPT PROGRAMMING

VECTORED INTERRUPT CONTROLLER (VIC)

FEATURES
• ARM PrimeCell™ Vectored Interrupt Controller
• 32 interrupt request inputs
• 16 vectored IRQ interrupts
• 16 priority levels dynamically assigned to interrupt requests
• Software interrupt generation
DESCRIPTION
The Vectored Interrupt Controller (VIC) takes 32 interrupt request inputs and programmably assigns them into 3 categories, FIQ,vectored IRQ, and non-vectored IRQ. The programmable assignment scheme means that priorities of interrupts from the various peripherals can be dynamically assigned and adjusted.Fast Interrupt reQuest (FIQ) requests have the highest priority. If more than one request is assigned to FIQ, the VIC ORs the requests to produce the FIQ signal to the ARM processor. The fastest possible FIQ latency is achieved when only one request is classified as FIQ, because then the FIQ service routine can simply start dealing with that device. But if more than one request
is assigned to the FIQ class, the FIQ service routine can read a word from the VIC that identifies which FIQ source(s) is (are) requesting an interrupt. Vectored IRQs have the middle priority, but ony 16 of the 32 requests can be assigned to this category. Any of the 32 requests can be assigned to any of the 16 vectored IRQ slots, among which slot 0 has the highest priority and slot 15 has the lowest.
Non-vectored IRQs have the lowest priority. The VIC ORs the requests from all the vectored and non-vectored IRQs to produce the IRQ signal to the ARM processor. The IRQ service routine can start by reading a register from the VIC and jumping there. If any of the vectored IRQs are requesting, the VIC provides the address of the highest-priority requesting IRQs service routine, otherwise it provides the address of a default routine that is shared by all the non-vectored IRQs. The default routine can read another VIC register to see what IRQs are active. All registers in the VIC are word registers. Byte and half word reads and write are not supported. Additional information on the Vectored Interrupt Controller is available in the ARM PrimeCell™ Vectored Interrupt Controller
(PL190) documentation.

INTERRUPT SOURCES

Port blinking using Timer0 External Match(ARM7(LPC2129/38))

#include<lpc21xx.h>
int main()
{
IO1DIR=0XFFFFFFFF;
PINSEL1=0X00003000;
T0TCR=1;
T0TC=0;
T0MCR=0X003;
T0MR0=0X00FFFFFF;
T0EMR=0X031;
while(1)
{
while((T0IR&0X01)==0);
IO1SET=0XFFFFFFFF;
T0IR=0XFF;
while((T0IR&0X01)==0);
IO1CLR=0XFFFFFFFF;
T0IR=0XFF;
}
}

Port blinking using Timer0 Capture control(ARM7(LPC2129/38)

#include<lpc21xx.h>
int main()
{
IO1DIR=0XFFFFFFFF;
PINSEL1=0X00802000;
T0TCR=1;
T0TC=0;
T0MCR=0X001;
T0MR0=0X00FFFFFF;
T0CCR=0X009;
while(1)
{
while((T0IR&0X01)==0);
IO1SET=0XFFFFFFFF;
T0IR=0XFF;
while((T0IR&0X01)==0);
IO1CLR=0XFFFFFFFF;
T0IR=0XFF;
}
}

PORT Blinking using TIMER0 MATCH (LPC2129/38)

 #include<lpc21xx.h>

 int main()

 {

 IO1DIR=0XFFFFFFFF;

 T0TCR=1;

 T0MCR=0x019;

 T0TC=0X00000000;

 T0MR0=0X000F0000;

 T0MR1=0X00FF0000;

 while(1)

 {

 T0IR=0XFF;

 while((T0IR&0X01)==0);

 IO1SET=0XFFFFFFFF;

 while((T0IR&0X02)==0);

 IO1CLR=0XFFFFFFFF;

  }

  }

ARM7(LPC2129/38) : TIMER0 AND TIMER1

Timer0 and Timer1 are functionally identical except for the peripheral base address.

FEATURES
• A 32-bit Timer/Counter with a programmable 32-bit Prescaler.
• Up to four 32-bit capture channels per timer, that can take a snapshot of the timer value when an input signal transitions. A
capture event may also optionally generate an interrupt.
• Four 32-bit match registers that allow:
- Continuous operation with optional interrupt generation on match.
- Stop timer on match with optional interrupt generation.
- Reset timer on match with optional interrupt generation.
• Up to four external outputs corresponding to match registers, with the following capabilities:
- Set low on match.
- Set high on match.
- Toggle on match.
- Do nothing on match.

APPLICATIONS
• Interval Timer for counting internal events.
• Pulse Width Demodulator via Capture inputs.
• Free running timer.

REGISTER DESCRIPTION

UART TRANSMITTER IN ARM7(LPC2129/38)

#include<lpc21xx.h>
int main()
{

PINSEL0=0X00000001;
U0LCR=0X83;
U0DLL=0X51;
U0DLM=0X00;
U0LCR=0X03;
U0THR='A';
while((U0LSR&0X20)==0);
while(1);
}

UART RECEIVER IN ARM7(LPC2129/38)

#include<lpc21xx.h>
void cmd(int);
void cmd1(int);
void data(char);
void delay();
int main()
{
char s;
PINSEL0=0X00000004;
IO1DIR=0XFFFFFFFF;
cmd(0x30);
cmd(0x30);
cmd(0x30);
cmd(0x20);
cmd1(0x28);
cmd1(0x01);
cmd1(0x06);
cmd1(0x0e);
cmd1(0x80);

U0LCR=0X83;
U0DLL=0X51;
U0DLM=0X00;
U0LCR=0X03;

while(1)
{
while((U0LSR&0X01)==0);
s=U0RBR;
data(s);
 }
 }

 void cmd(int b)
{
unsigned int s;
s=b&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;
}
void cmd1(int a)
{


unsigned int s;
s=a&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;


s=a&0x0f;
IO1SET=s<<20;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
delay();
IO1CLR=0XFFFFFFFF;
}
void data(char a)
{

char s;
s=a&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X000A0000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;


s=a&0x0f;
IO1SET=s<<20;
IO1CLR=0X000F0000;
IO1SET|=0X000A0000;
delay();
IO1CLR=0X00080000;
delay();
IO1CLR=0XFFFFFFFF;
}
void delay()
{
int i;
for(i=0;i<10000;i++);
}

UART : ARM7(LPC2129/38)

The LPC2129/38  each contain two UARTs. In addition to standard transmit and receive data lines, the UART1 also provides a full modem control handshake interface.

Features
 • 16 B Receive and Transmit FIFOs.
 • Register locations conform to 16C550 industry standard.
 • Receiver FIFO trigger points at 1 B, 4 B, 8 B, and 14 B.
 • Built-in fractional baud rate generator covering wide range of baud rates without a need for external      crystals of particular values.
 • Transmission FIFO control enables implementation of software (XON/XOFF) flow control on both    UARTs
 • UART1 is equipped with standard modem interface signals. This module also provides full support    for hardware flow control (auto-CTS/RTS).

4x4 Keypad programming in ARM7(LPC2129/38)( text on LCD(using 4 data lines) according to buttons pressed )

#include<lpc21xx.h>
void delay();
void cmd(int);
void cmd1(int);
void data(char);
char keypad();
int main()
{
char k;
IO0DIR=0XFFFFC0FF;
IO1DIR=0XFFFFFFFF;
cmd(0x30);
cmd(0x30);
cmd(0x30);
cmd(0x20);
cmd1(0x28);
cmd1(0x01);
cmd1(0x06);
cmd1(0x0e);
cmd1(0x80);
while(1)
{
k=keypad();
if(k!='z')
data(k);
}
}
char keypad()
{
int e;
IO0CLR=0XFFFFFFFF;
IO0SET=0X0001C000;
e=IO0PIN&0X00003C00;
switch(e)
{
case 0x00001C00:
return '1';
break;
case 0x00002C00:
return '2';
break;
case 0x00003400:
return '3';
break;
case 0x00003800:
return '4';
break;
}

IO0CLR=0XFFFFFFFF;
IO0SET=0X0002C000;
e=IO0PIN&0X00003C00;
switch(e)
{
case 0x00001C00:
return '5';
break;
case 0x00002C00:
return '6';
break;
case 0x00003400:
return '7';
break;
case 0x00003800:
return '8';
break;
}

IO0CLR=0XFFFFFFFF;
IO0SET=0X00034000;
e=IO0PIN&0X00003C00;
switch(e)
{
case 0x00001C00:
return '9';
break;
case 0x00002C00:
return '0';
break;
case 0x00003400:
return 'a';
break;
case 0x00003800:
return 'b';
break;
}

IO0CLR=0XFFFFFFFF;
IO0SET=0X00038000;
e=IO0PIN&0X00003C00;
switch(e)
{
case 0x00001C00:
return 'c';
break;
case 0x00002C00:
return 'd';
break;
case 0x00003400:
return 'e';
break;
case 0x00003800:
return 'f';
break;

default:
return 'z';
break;
}
}

 void cmd(int b)
{
unsigned int s;
s=b&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;
}

void cmd1(int a)
{
unsigned int s;
s=a&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;


s=a&0x0f;
IO1SET=s<<20;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
delay();
IO1CLR=0XFFFFFFFF;
}

void data(char a)
{
char s;
s=a&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X000A0000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;


s=a&0x0f;
IO1SET=s<<20;
IO1CLR=0X000F0000;
IO1SET|=0X000A0000;
delay();
IO1CLR=0X00080000;
delay();
IO1CLR=0XFFFFFFFF;
}

void delay()
{
int i;
for(i=0;i<500000;i++);
}

LCD Programming using 4 data lines in ARM7(LPC2129/38)

#include<lpc21xx.h>
void cmd(int);
void cmd1(int);
void data(char);
void delay();
void print(const char *p)
{
while(*p)
data(*p++);
}
int main()
{
IO1DIR=0XFFFFFFFF;
cmd(0x30);
cmd(0x30);
cmd(0x30);
cmd(0x20);
cmd1(0x28);
cmd1(0x01);
cmd1(0x06);
cmd1(0x0e);
cmd1(0x80);
print("hello world");
while(1);
}
void cmd(int b)
{
unsigned int s;
s=b&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;
}

void cmd1(int a)
{
unsigned int s;
s=a&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;


s=a&0x0f;
IO1SET=s<<20;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
delay();
IO1CLR=0XFFFFFFFF;
}
void data(char a)
{

char s;
s=a&0xf0;
IO1SET=s<<16;
IO1CLR=0X000F0000;
IO1SET|=0X000A0000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;


s=a&0x0f;
IO1SET=s<<20;
IO1CLR=0X000F0000;
IO1SET|=0X000A0000;
delay();
IO1CLR=0X00080000;
delay();
IO1CLR=0XFFFFFFFF;
}
void delay()
{
int i;
for(i=0;i<10000;i++);
}

16X2 LCD (LM016L) Programming in ARM7(LPC2138) (display the message "hello world")

#include<lpc21xx.h>
void delay();
void cmd1(int);
void data(char);
void display(const char *p)
{
while(*p)
data(*p++);
}
int main()
{
IO1DIR=0XFFFFFFFF;
cmd1(0x38);
cmd1(0x01);
cmd1(0x06);
cmd1(0x0e);
cmd1(0x80);

display("hello world");
while(1);
}

void cmd1(int a)
{
IO1SET=a<<20;
IO1CLR=0X000F0000;
IO1SET|=0X00080000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;

}
void data(char a)
{
IO1SET=a<<20;
IO1CLR=0X000F0000;
IO1SET|=0X000A0000;
delay();
IO1CLR=0X00080000;
IO1CLR=0XFFFFFFFF;

}
void delay()
{
int i;
for(i=0;i<1000000;i++);
}

LED Blinking and Chaser using Switches in ARM7(LPC2129/38)

 #include<lpc21xx.h>

 void delay();
 int main()
 {  
 int i;
 IO1DIR=0XFFFFFFFF;
 IO0DIR=0X00000000;

 while(1)
 {
 if((IO0PIN&0X00000001)==1)
 {
 IO1SET=0X00010000;
 delay();
 for(i=0;i<15;i++)
 {
 IO1SET=IO1SET<<1;
 IO1CLR=IO1SET>>1;
 delay();
 }
 }
 else if((IO0PIN&0X00000002)==2)
 {
 IO1SET=0XFFFFFFFF;
 delay();
 IO1CLR=0XFFFFFFFF;
 delay();
 }
 }
 }
 void delay()
 {int i;
 for(i=0;i<1000000;i++);
 }

Chaser in ARM7(LPC2129/38)

 #include<lpc21xx.h>
 void delay();
 int main()
 {
 int i;
 IO1DIR=0X00FF0000;         // pin nos 16 to 23(port 1) as chaser o/p

 while(1)
 {
 IO1SET=0X00010000;      
 delay();
 for(i=0;i<7;i++)
 {
 IO1SET=IO1SET<<1;
 IO1CLR=IO1SET>>1;
 delay();
 }
 }
 }
 void delay()
 {
 int i;
 for(i=0;i<1000000;i++);
 }

LED Blinking in ARM7(LPC2129/38)

 #include<lpc21xx.h>
 void delay();
 int main()
 {
  int i;
 IO0DIR=0XFFFFFFFF;

 while(1)
 {
 IO0SET=0XFFFFFFFF;
 delay();
 IO0CLR=0XFFFFFFFF;
 delay();
 }

 }


 void delay()
 {
int i;
 for(i=0;i<1000000;i++);
}