~: Sample Programs in Keil for 8051 :~
example-1: generate a square wave of 100 Hz at pin P1.0 of 8051 using timer
#include
sbit pin = P1^0; // decleare a variable type sbit for P1.0
main()
{
P1 = 0x00; // clear port
TMOD = 0x09; // initialize timer 0 as 16 bit timer
loop:TL0 = 0xAF; // load valur 15535 = 3CAFh so after
TH0 = 0x3C; // 50000 counts timer 0 will be overflow
pin = 1; // send high logic to P1.0
TR0 = 1; // start timer
while(TF0 == 0) {} // wait for first overflow for 50 ms
TL0 = 0xAF; // again reload count
TH0 = 0x3C;
pin = 0; // now send 0 to P1.0
while(TF0 == 0) {} // wait for 50 ms again
goto loop; // continue with the loop
}
example-2: write a program to make 8 to 1 multiplexer with enable signal
#include
sbit D0 = P0^0; // set P0.0-P0.7 (D0-D7) as input pins of mux
sbit D1 = P0^1;
sbit D2 = P0^2;
sbit D3 = P0^3;
sbit D4 = P0^4;
sbit D5 = P0^5;
sbit D6 = P0^6;
sbit D7 = P0^7;
sbit S0 = P1^0; // set P1.0-P1.2(S0-S2) as select pins of mux
sbit S1 = P1^1;
sbit S2 = P1^2;
sbit EN = P1^7; // set P1.7 as enable pin
sbit pin = P3^5; // set P3.5 as output
main()
{
P3=0x00;P0=0xFF; // clear op and set all ips
TMOD = 0x01; // set timer 0 for 16 bit timer
next:TL0 = 0xAF; // load count
TH0 = 0x3C;
while(EN==1){} // wait till enable pin becomes 0
if((S0==0)&&(S1==0)&&(S2==0)) pin = D0; // if select inputs are 000 op is first ip
else if((S0==1)&&(S1==0)&&(S2==0)) pin = D1; // if select inputs are 001 op is second ip
else if((S0==0)&&(S1==1)&&(S2==0)) pin = D2; // same as above
else if((S0==1)&&(S1==1)&&(S2==0)) pin = D3;
else if((S0==0)&&(S1==0)&&(S2==1)) pin = D4;
else if((S0==1)&&(S1==0)&&(S2==1)) pin = D5;
else if((S0==0)&&(S1==1)&&(S2==1)) pin = D6;
else if((S0==1)&&(S1==1)&&(S2==1)) pin = D7;
else pin = 0; // by default op is cleared
TR0 = 1; // start timer 0
while(TF0==0){} // wait until overflow means 50ms
TR0 = 0; // stop timer
goto next; // go for next input
}
Example-3: take parallal input from port P1 convert it into serial and send it via P0.0
#include
sbit sout = P0^0; // serial out on P0.0
sbit D0 = P1^0; // parallal input from P1 (D0-D7)
sbit D1 = P1^1;
sbit D2 = P1^2;
sbit D3 = P1^3;
sbit D4 = P1^4;
sbit D5 = P1^5;
sbit D6 = P1^6;
sbit D7 = P1^7;
int i;
void delay(void); // 1 ms delay
main()
{
for(i=0;i<8;i++) // rotate loop for 8 times
{
sout = D0; // first bit out
D0 = D1; // shift all bits in sequence
D1 = D2;
D2 = D3;
D3 = D4;
D4 = D5;
D5 = D6;
D6 = D7;
delay(); // generate 1 ms delay after each bit shifted
}
}
void delay()
{
int k
for(k=0;k<1000;k++);
}
Example-4: write a program to symulteneously transmit and receive data.
#include
main()
{
TMOD=0x20; // set timer1 in 16 bit timer mode
SCON=0x40; // initialize serial communication
TL1=0xFD; // load timer 1 to generate baud rate of 96KBps
TH1 = 0xFD;
TR1 = 1; // start timer 1
loop:REN = 1; // enable reception
while(RI==0){} // wait until data is received
RI=0; // clear receive flag
ACC = SBUF; // get data in to acc
REN = 0; // now disable reception
SBUF = ACC; // start transmission
while(TI==0){} // wait until data transmitted
TI=0; // clear transmission flag
goto loop; // continue this cycle
}
example-5: detect an external interrupt on P3.2 and P3.3. indicate on LEDs connected on P0.0 & P0.1
#include
sbit op1=P0^0; // LED1 as output on P0.0
sbit op2=P0^1; // LED2 as ouput on P0.1
void delay(void); // 10 ms delay
void intrupt0(void) interrupt 0 // ext interrupt 0 vector
{
op1=0; // indication on LED1
delay();
op1=1;
}
void intrupt1(void) interrupt 2 // ext interrupt 1 vector
{
op2=0; // indication on LED2
delay();
op2=1;
}
void delay() // delay for 10 ms
{
int x;
for(x=0;x<10000;x++);
}
void main()
{
P0=0xFF; // send all 1's to P0
IE=0x85; // enable both ext interrupts
while(1); // continuous loop
}
Example-6: blink a LED on P2.0 for 5 second using timer 1
#include
int c=0; // initialize counter to 0
sbit LED= P2^0; // LED connected to P2.0
void timer1(void) interrupt 3 // timer 1 overflow vactor
{
TF1=0; // clear overflow flag
c++; // increment counter
if(c==100) // if 100 counts of 50 ms(= 5 sec) are over
{
TR1=0; // stop timer
LED=0; // LED off
}
TH1=0x3C; // other reaload timer 1 with
TL1=0xAF; // 15535 to count 50 ms
}
void main()
{
P2=0x00; // clear op
TMOD=0x90; // set timer 1
TH1=0x3C; // load count 15535
TL1=0xAF;
IE=0x88; // enable timer 1 interrupt
LED=1; // LED on
TR1=1; // timer 1 start
while(1); // continuous loop
}
Example 7: send ultrasonic wave through P1.0 and receive its echo through P3.2. generate an interrupt. calculate the distance of object.
#include
sbit tx = P1^0; // transmitter pin
int c=0,d=0; // counter and distance
void tmr0(void) interrupt 1 // timer 0 interrupt vector
{
TF0=0; // clear timer flag
c++; // increment counter
TL0 = 0xAF; // reload values
TH0 = 0x3C;
}
void int0(void) interrupt 0 // ext interrupt 0 vector
{
TR0 = 0; // stop timer
d = c*30; // get distance = time*velocity
}
main()
{
IE=0x83; // enable interrupts
IP=0x01; // high priority for ext interrupt
TMOD = 0x01; // timer 0 as 16 bit timer
P1 = 0x00; // clear op port
TL0 = 0xAF; // load values for 50 ms
TH0 = 0x3C;
tx = 1; // enable transmission
TR0 = 1; // start timer
while(1);
}
Example 8: take input from P0. count no of 1 in input
#include
sbit D0 = B^0; // define D0-D7 as bits of reg B
sbit D1 = B^1;
sbit D2 = B^2;
sbit D3 = B^3;
sbit D4 = B^4;
sbit D5 = B^5;
sbit D6 = B^6;
sbit D7 = B^7;
unsigned bdata reg; // define reg as bit addressable variable
sbit b = reg^0; // define b as bit 0 of reg
void main()
{
unsigned int i,c=0; // initialize counter
B=P0; // take input from P0 to B
b=0;
for(i=0;i<8;i++) // rotate bits of reg B
{ // 8 times
b=D7;
D7=D6;
D6=D5;
D5=D4;
D4=D3;
D3=D2;
D2=D1;
D1=D0;
if(b==1)c++; // check every bit if 1
}
while(1); // loop continue
}
Example 9: connect key with P3.2. using interrupt count no of key press and display it on common anode seven segment display connected to P0.
#include
unsigned int c=0,x=0; //initialize key counter and key flag
void extint0(void) interrupt 0
{
x=1; // set key flag
c++; // increment key count
if(c==9) // if its 9
{
c=0; // reset it to 0 and
P0=0xC0; // display 0
}
}
void main(void)
{
IE=0x81; // enable ext int 0
P0=0xC0; // display 0
loop:while(!x); // check key flag
switch(c) // if it is set get the count
{
case 1:
P0=0xF9; // display digit from 1 to 9
break;
case 2:
P0=0xA4;
break;
case 3:
P0=0xB0;
break;
case 4:
P0=0x99;
break;
case 5:
P0=0x92;
break;
case 6:
P0=0x82;
break;
case 7:
P0=0xF8;
break;
case 8:
P0=0x80;
break;
case 9:
P0=0x90;
break;
}
x=0; // clear key flag
goto loop; // loop continue
}
Example 10: connect 8 keys with P1. detect keypress and display number on CA 7 segment display connected to P0.
#include
void main(void)
{
loop:P1=0xFF; // send all 1's to P1
while(P1==0xFF); // remain within loop till key is not pressed
switch(P1) // when key pressed detect is
{
case 0xFE:
P0=0xF9; // and display digit from 1 to 8
break;
case 0xFD:
P0=0xA4;
break;
case 0xFB:
P0=0xB0;
break;
case 0xF7:
P0=0x99;
break;
case 0xEF:
P0=0x92;
break;
case 0xDF:
P0=0x82;
break;
case 0xBF:
P0=0xF8;
break;
case 0x7F:
P0=0x80;
break;
}
goto loop;
}
LED Interfacing:
Hardware:- total 32 LEDs are connected one with each i/o line. Anodes of all 32 LEDs are tied to Vcc and cathode is connected with port pin. Here is the program to generate different chasing effects one after another continuously.
#include
void delay(void);
void delay()
{
int a,b;
for(a=0;a<100;a++)
for(b=0;b<1000;b++);
}
void main()
{
int i, j, k, l;
for(i=0;i<50;i++) // ON-OFF effect
{
P0=0x00;
P1=0x00;
P2=0x00;
P3=0x00
Delay();
P0=0xFF;
P1=0xFF;
P2=0xFF;
P3=0xFF;
Delay();
}
for(j=0;j<50;j++) // alternate blinking effect
{
P0=0x55;
P1=0x55;
P2=0x55;
P3=0x55
Delay();
P0=0xAA;
P1=0xAA;
P2=0xAA;
P3=0xAA;
Delay();
}
for(k=0;k<50;k++) // ON-OFF effect for port lower and upper nibble
{
P0=0xF0;
Delay();
P0=0x0F;
Delay();
P0=0xFF
P1=0xF0;
Delay();
P1=0x0F;
Delay();
P1=0xFF
P2=0xF0;
Delay();
P2=0x0F;
Delay();
P2=0xFF
P3=0xF0;
Delay();
P3=0x0F;
Delay();
P3=0xFF;
}
for(l=0;l<50;l++) // alternate switching of ports one by one
{
P0=0x00
Delay();
P0=0xFF;
P1=0x00;
Delay();
P1=0xFF;
P2=0x00
Delay();
P2=0xFF;
P3=0x00;
Delay();
P3=0xFF;
}
Push button keypad and 7-segment interfacing:
Hardware:-8 push buttons are connected with P2 with one terminal as common ground. A common anode type 7-segment display is connected to P0. the program displays number 1 to 8 on 7-segment depending upon the key is pressed
#include
void main(void)
{
loop:P2=0xFF; // send all 1's to P1
while(P21==0xFF); // remain within loop till key is not pressed
switch(P1) // when key pressed detect is
{
case 0xFE:
P0=0xF9; // and display digit from 1 to 8
break;
case 0xFD:
P0=0xA4;
break;
case 0xFB:
P0=0xB0;
break;
case 0xF7:
P0=0x99;
break;
case 0xEF:
P0=0x92;
break;
case 0xDF:
P0=0x82;
break;
case 0xBF:
P0=0xF8;
break;
case 0x7F:
P0=0x80;
break;
}
goto loop;
LCD interfacing:
Hardware:- normally all types of text LCDs have 8 data pins and 3 control signals. here data pins are connected with P0 and three control pins RS, R/W and EN are connected with P2.7, P2.6 & P2.5 respectively. Its a 16X2 LCD.
#include
#include
sbit rs = P2^7; // declare P2.7 as rs pin
sbit en = P2^5; // declare p2.5 as enable pin
sbit rw = P2^6; // declare p2.6 as read/write pin
sbit b = P0^7; // busy flag
void writecmd(unsigned char a); // function to send command to LCD
void writedat(unsigned char b); // function to send data to LCD
void busy(); // function to check LCD is busy or not
void writestr(unsigned char *s); // function to write string on LCD
void writecmd(unsigned char a)
{
busy(); // check for LCD is busy or not
rs = 0; // clear rs pin for command
rw = 0; // clear rw pin to write
P0 = a; // send command character
en = 1; // strob LCD
en = 0;
}
void writedat(unsigned char b)
{
busy(); // check for LCD is busy or not
rs = 1; // set rs pin for data
rw = 0; // clear rw pin to write
P0 = b; // send data character
en = 1; // strob LCD
en = 0;
}
void busy()
{
en = 0; // disable display
P0 = 0xFF; // configur P0 as input
rs = 0; // clear rs pin for command
rw = 1; // set rw pin to read
while(b==1)
{
en=0; // strob LCD till P0.7 is 1
en=1;
}
en=0;
}
void writestr(unsigned char *s)
{
unsigned char l,i;
l = strlen(s); // get the length of string
for(i=1;i
while(1) // continuous loop
}
ADC interfacing:
Hardware:- here I have interfaced 8 bit ADC 0804 with 8051 and given program displays digital equivalent value (HEX) of any analog input on 2-digit multiplex seven segment. Usually ADC has four control signals. CS (chip select-active low), WR (SOC-start of conversion-active low), RD(OE-o/p enable-active low)and INT. from these four only INT is o/p form ADC all other are inputs. The CS is connected with ground. WR, RD and INT signals are connected with P3.0, P3.1 and P3.2 respectively. 8 data pins are connected with P1. Multiplex 7-segment has 8 data pins and 2 display select pins. data pins are connected with P0 and display select pins are connected to P2.7 and P2.6 respectively.
#include
#include
sbit wr = P3^0; // ADC write enable
sbit rd = P3^1; // ADC read enable
sbit d1 = P2^7 // display 1 select bit
sbit d2 = P2^6 // display 2 select bit
unsigned char data d;
unsigned int a=0,b=0,c=0;
void int1(void) interrupt 1 //external interrupt 1 subroutine
{
EA=0 // first disable any other interrupt
rd = 0; // send read signal
d=P1; // read the data from port
rd=1;
a = (d & 0x0F); // saperate upper and lower
b = d >> 4; // nibbles
EA=1; // again enable interrupts
}
void tmr1(void) interrupt 3 // timer 1 overflow interrupt
{
c++; // count no of timer 1 interrupts
TH1=0xEC; // reload timer
TL1=0x77;
TF1=0; // clear timer 1 overflow flag
if((c%2)==0) // check interrupt has arrived even
{ // times or odd times
d1=1; // alternatively change display
d2=0; // for even times
P0=b;
}
else // and odd times
{
d1=0;
d2=1;
P0=a;
}
}
main()
{
P0=0x00; // P0 output ports
P1=0xFF; // P1 input port
TMOD=0x90; // initialize T1 as 16 bit timer
TH1=0xEC; // load count 60535(=EC77h)
TL1=0x77; // so it will overflow after 5 ms
TR1=1; // start timer
d1=0;
d2=1; //enable first display
P0=a; //display 0 initially
IE=0x89; // enable external and timer interrupts
wr = 0; // send write signal
wr = 1;
while(1); // wait in continuous loop
}
DAC interfacing:
Hardware:-a 8 bit DAC is connected to P2. Its two control signals WR and CS are tied to ground. Here I am writing a program to generate three different types of waveforms square, triangular and staircase type. To select desire waveform three push buttons are connected at P3.0 to P3.2.
#include
void delay1(); //key debounce delay
void delay2(); // delay for frequency
void sqrarwave(); // function to generate square wave
void triwave(); // function to generate triangular wave
void stairwave(); // function to generate staircase wave
void delay1() // approx. 100 ms delay
{
int a,b;
for(a=0;a<100;a++)
for(b=0;b<1000;b++);
}
void delay2() // approx 1 ms delay
{
int c;
for(c=0;c<1000;c++);
}
void squarwave()
{
while(P3==0xFF) // till any button is not pressed
{
P2=0xFF; // first send all high to P2
Delay2();
P2=0x00; // then send all low to P2
Delay2();
}
}
void triwave()
{
unsigned char d;
while(P3==0xFF)
{
for(d=0x00;d<0xFF;d++) // send values 00 to FF
{
P2=d; // one by one for positive ramp
}
for(d=0xFF;d<0x00;d--) // send values FF to 00
{
P2=d; // one by one for negative ramp
}
}
void stairwave()
{
while(P3==0xFF)
{
P2=0x00; // step by step increment
Delay2();
P2=0x20; // values sent to P2
Delay2();
P2=0x40;
Delay2();
P2=0x80;
Delay2();
}
}
void main()
{
P2=0x00; // P2 as output port
P3=0xFF; // P3 as input port
While(P3=0xFF); // wait till any button is pressed
Switch(P3)
{
case 0xFE: // for first button
delay1(); // key debounce delay
P3=0xFF; // send all 1’s again to P3
squarwave(); // generate square wave
break;
case 0xFD:
delay1();
P3=0xFF;
triwave();
break;
case 0xFB:
delay1();
P3=0xFF;
stairwave();
break;
}
}
