SQUARE WAVE
GENERATOR
AIM:
To develop the source code for square wave generator using Keil µ vision
and to implement it using Proteus tool.
THEORY:
One requirement in a wide range of applications is a spontaneous source
of some continuous signal, having a regular and definable wave shape. One of the
most important of these is a square wave.
The circuit to the right uses a comparator with both positive and
negative feedback to control its output voltage. Because the negative feedback
path uses a capacitor while the positive feedback path does not, however, there
is a time delay before the comparator is triggered to change state. As a
result, the circuit oscillates, or keeps changing state back and forth at a
predictable rate.
SOURCE
CODE:
#include<regx51.h>
sfr out1=0x90;
sfr out2=0xa0;
sfr out3=0xb0;
unsigned int i;
void main()
{
out1=out2=out3=0x00;
while(1)
{
out1=out2=out3=0xaa;
for(i=0;i<25000;i++);
out1=out2-out3=0x55;
for(i=0;i<25000;i++);
}
}
RESULT:
Thus the source code for square wave generator
is written using Keil and implemented in Proteus and verified.
BCD TO SEVEN SEGMENT
DISPLAY
AIM:
To develop the source code for BCD to seven segment display using Keil µ
vision and to implement it using Proteus tool.
THEORY:
A 7-segment display is a
form of electronic display device for displaying decimal
numerals that is an alternative to the more
complex dot-matrix
displays. Seven-segment displays are widely used in digital clocks,
electronic meters, and other electronic devices for displaying numerical
information.
The seven segments are
arranged as a rectangle
of two vertical segments on each side with one horizontal segment on the top,
middle, and bottom. The segments of a 7-segment display are referred to by the
letters A to G, where the optional DP decimal point
(an "eighth segment") is used for the display of non-integer numbers.
BCD I/P
|
SEGMENT O/P
|
DISPLAY
|
g f e d c b a
|
||
0
0 0 0
|
0 1 1 1 1 1 1
|
0
|
0
0 0 1
|
0 0 0 0 1 1 0
|
1
|
0
0 1 0
|
1 0 1 1 0 1 1
|
2
|
0
0 1 1
|
1 0 0 1 1 1 1
|
3
|
0
1 0 0
|
0 1 1 0 0 1 1
|
4
|
0
1 0 1
|
1 1 0 1 1 0 1
|
5
|
0
1 1 0
|
0 0 1 1 1 1 1
|
6
|
0
1 1 1
|
0 0 0 0 1 1 1
|
7
|
1
0 0 0
|
1 1 1 1 1 1 1
|
8
|
1
0 0 1
|
1 1 0 0 1 1 1
|
9
|
SOURCE
CODE:
#include<regx51.h>
sfr out=0xA0; //P3
sfr inp=0x90; //P1
unsigned char temp;
unsigned char const lookup[10]=
{0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};
void main()
{
out=0x00;
inp=0xFF;
while(1)
{
temp=inp & 0x0F;
if(temp>=0x0A)
out=0x00;
else
out=~(lookup[temp]);
}
}
RESULT:
Thus the source code for BCD to seven segment display is written using
Keil and implemented in Proteus and verified.
TWO SEVEN SEGMENT
DISPLAY
AIM:
To develop the source code for two seven segment display using Keil µ
vision and to implement it using Proteus tool.
THEORY:
There are two types of LED 7-segment
displays: common cathode (CC) and common anode (CA). The difference between the
two displays is the common cathode has all the cathodes of the 7-segments
connected directly together and the common anode has all the anodes of the
7-segments connected together. Shown below is a common anode seven segment.
As shown above all the anode segments are
connected together. When working with a CA seven segment displays, power must
be applied externally to the anode connection that is common to all the
segments. Then by applying a ground to a particular segment connection (a-g),
the appropriate segment will light up. An additional resistor must be added to
the circuit to limit the amount of current flowing through each LED segment.
A common cathode seven segment is
different from a common anode segment in that the cathodes of all the LEDs are
connected together. For the use of this seven segment the common cathode
connection must be grounded and power must be applied to appropriate segment in
order to illuminate that segment.
SOURCE CODE:
#include<regx51.h>
sfr out1=0xa0;
sfr out2=0xb0;
#define max 36000
unsigned int i,
temp=0x00;
unsigned char const
lookup[10]=
{0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};
void main(void)
{
out1=0x00;
out2=0x00;
while(1)
{
if(temp!=100)
{
out1=~(lookup[temp/10]); //MSB
out2=~(lookup[temp%10]); //LSB
for(i=0;i<max;i++);
temp++;
}
else
temp=0x00;
}
}
RESULT:
Thus the source code for two seven segment display is written using Keil
and implemented in Proteus and verified.
3 PHASE USING TIMER
AIM:
To develop the source code for 3 phase timer using Keil µ vision and to
implement it using Proteus tool.
THEORY:
In electrical engineering, three-phase electric power systems have at
least three conductors carrying voltage waveforms that are 2π⁄3 radians (120°,
1⁄3 of a cycle) offset in time. In this article angles will be measured in
radians except where otherwise stated.
Let x be
the instantaneous phase of a signal of frequency f at time t:
Using this, the waveforms for the three phases are,
where VP is the peak voltage and
the voltages on L1, L2 and L3 are measured relative to the neutral.
REGISTER DESCRIPTION:
TMOD : Counter/Timer Mode Register
·
GATE : Permits INTx pin to enable/disable counter.
·
C/T
: Set for counter operation, reset for
timer operation.
·
M1,
M0 :
00
: Emulate 8048 counter/timer (13-bits).
01
:16-bit counter/timer.
10
: 8-bit auto-reload mode
11
:Timer 0 = two 8-bit timers.
TCON : Counter/Timer Control Register
·
TF1,
TF0 : Overflow flags for Timer 1 and Timer 0.
·
TR1,
TR0 : Run control bits for Timer 1 and Timer 0. Set to run, reset to hold.
·
IE1,
IE0 : Edge flag for external interrupts 1 and 0. Set by interrupt edge, cleared
when interrupt is processed.
·
IT1,
IT0 : Type bit for external interrupts. Set for falling edge interrupts, reset
for 0 level interrupts.
TL0/TH0 : Timer 0 Low byte & Timer 0
High byte. These two SFRs, taken together, represent timer 0. This increments
for each clock cycle.
SOURCE
CODE:
#include<regx51.h>
sbit r=0xA0; //P2.0
sbit g=0xA1; //P2.1
sbit b=0xA2; //P2.2
void delay(void);
void main(void)
{
r=g=b=0;
while(1)
{
r=1;
delay();
r=0;g=1;
delay();
g=0;b=1;
delay();
b=0;
}
}
void delay()
{
TMOD=0x01;
TH0=0xE6;
TL0=0x37;
TR0=1;
while(TF0==0);
TF0=0;
}
RESULT:
Thus the source code for clock using timer is written using Keil and
implemented in Proteus and verified.
CIRCUIT
SCHEMATIC & OUTPUT:
REAL
TIME CLOCK USING TIMER
AIM:
To develop the source code for clock using timer using Keil µ vision and
to implement it using Proteus tool.
THEORY:
A clock is an instrument
used to indicate, keep, and co-ordinate time. The word clock is derived
ultimately (via Dutch, Northern French, and Medieval Latin) from the Celtic
words clagan and clocca meaning "bell". A silent instrument missing
such a mechanism has traditionally been known as a timepiece. In general usage
today a "clock" refers to any device for measuring and displaying the
time. Watches and other timepieces that can be carried on one's person are
often distinguished from clocks.
A real-time clock (RTC)
is a computer clock (most often in the form of an integrated circuit) that
keeps track of the current time. Although the term often refers to the devices
in personal computers, servers and embedded systems, RTCs are present in almost
any electronic device which needs to keep accurate time.
REGISTER DESCRIPTION:
IE : Interrupt Enable Register
·
EA
: Global interrupt enable.
·
ES
: Serial interrupt enable flag
·
ET1
: Timer 1 interrupt enable flag.
·
EX1
: External interrupt 1 (INT1) interrupt
enable flag.
·
ET0
: Timer 0 interrupt enable flag.
·
EX0
: External interrupt 0 (INT0) interrupt
enable flag.
SOURCE
CODE:
#include<regx51.h>
sfr min1=0xB0; //P3
sfr min10=0x90; //P1
sfr sec1=0xA0; //P2
sfr sec10=0x80; //P0
unsigned int MIN,SEC,a=0x00;
code unsigned char const
lut[]=
{0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};
void main(void)
{
MIN=SEC=0;
IE=0x82;
TMOD=0x01;
TR0=1;
while(1)
{
sec10=~(lut[SEC/10]);
sec1=~(lut[SEC%10]);
min10=~(lut[MIN/10]);
min1=~(lut[MIN%10]);
}
}
void t0_isr(void)
interrupt 1
{
a++;
if(a==15)
{ a=0x00;
SEC++;
}
if(SEC==60)
{ SEC=a=0x00;
MIN++;
}
if(MIN==60)
MIN=0x00;
}
RESULT:
Thus the source code for clock using timer is written using Keil and
implemented in Proteus and verified.
FREQUENCY
MULTIPLIER
AIM:
To develop the source code for frequency
multiplier using Keil µ vision and to implement it using Proteus tool.
THEORY:
In
electronics, a frequency
multiplier is an electronic
circuit that generates an output signal whose output frequency is a harmonic (multiple) of its input frequency. Frequency
multipliers consist of a nonlinear circuit that distorts the input signal and
consequently generates harmonics of the input signal. A subsequent band pass filter selects the desired harmonic frequency and removes
the unwanted fundamental and other harmonics from the output.
Frequency multipliers are often used in frequency
synthesizers and
communications circuits. It can be more economic to
develop a lower frequency signal with lower power and less expensive devices,
and then use a frequency multiplier chain to generate an output frequency in
the microwave or millimeter wave range. Some modulation schemes, such
as frequency
modulation, survive the
nonlinear distortion without ill effect (but schemes such as amplitude
modulation do not).
Frequency multiplication is also used in nonlinear optics. The nonlinear distortion in crystals
can be used to generate harmonics of laser light.
SOURCE
CODE:
#include<regx51.h>
sfr p1=0x90;
sbit in1=0x90;
sbit in2=0x91;
sbit in3=0x92;
sbit in4=0x93;
sbit out=0xa0;
unsigned int sum, f, t1;
void main(void)
{
t1=0x00;
IE=0x82;
TMOD=0x02;
TH0=TL0=0x00;
while(1)
{
f=0x01;
if(in1==0)
{
f=f*2;
}
if(in2==0)
{
f=f*4;
}
if(in3==0)
{
f=f*6;
}
if(in4==0)
{
f=f*8;
}
if((p1&0x0f)==0x0f)
{
TR0=0;
t1=0x01;
}
else
if(t1!=f)
{
t1=f;
sum=(255-(1000000/(f*2*1000)));
TH0=TL0=sum;
TR0=1;
}
}
}
void in(void) interrupt 1
{
out=~out;
}
RESULT:
Thus the
source code for frequency multiplier is written using Keil and implemented in
Proteus and verified.
FREQUENCY
ADDER
AIM:
To develop
the source code for frequency adder using Keil µ vision and to implement it
using Proteus tool.
THOERY:
The
frequency adder which has four inputs and one output. The frequency of the
output wave is depends upon the input switches if first switch ON, only the
frequency of the output wave is 2kHz.If the second switch ON, only the
frequency of the output wave is 4kHz. If the both switches ON condition the
frequency of the output wave is (2+4)6 kHz. Frequency
adders are often used in frequency
synthesizers and
communications circuits. It can be more economic to
develop a lower frequency signal with lower power and less expensive devices,
and then use a frequency adder chain to generate an output frequency in the microwave or millimeter wave range.
SOURCE
CODE:
#include<regx51.h>
sfr p1=0x90;
sbit in1=0x90;
sbit in2=0x91;
sbit in3=0x92;
sbit in4=0x93;
sbit out=0xa0;
unsigned int sum, f, t1;
void main(void)
{
t1=0x00;
IE=0x82;
TMOD=0x02;
TH0=TL0=0x00;
while(1)
{
f=0x00;
if(in1==0)
{
f=f+2;
}
if(in2==0)
{
f=f+4;
}
if(in3==0)
{
f=f+6;
}
if(in4==0)
{
f=f+8;
}
if((p1&0x0f)==0x0f)
{
TR0=0;
t1=0x00;
}
else
if(t1!=f)
{
t1=f;
sum=(255-(1000000/(f*2*1000)));
TH0=TL0=sum;
TR0=1;
}
}
}
void in(void) interrupt 1
{
out=~out;
}
RESULT:
Thus the
source code for frequency adder is written using Keil and implemented in
Proteus and verified.
SERIAL
TRANSMISSION
AIM:
To develop
the source code for serial transmission using Keil µ vision and to implement it
using Proteus tool.
THEORY:
In telecommunication and computer
science, serial communication is
the process of sending data one bit at a
time, sequentially, over a communication channel or computer
bus. This is in contrast to parallel communication, where
several bits are sent as a whole, on a link with several parallel channels.
Serial communication is used for all long-haul communication and most computer
networks, where the cost of cable and synchronization
difficulties make parallel communication impractical. Serial computer buses are
becoming more common even at shorter distances, as improved signal
integrity and transmission speeds in newer serial technologies have begun to
outweigh the parallel bus's advantage of simplicity (no need for serializer and
deserializer, or SerDes) and to outstrip its disadvantages (clock
skew, interconnect density).
Serial
transmission is the process of transmitting data, one bit at a time (one bit
after the other). Contrast with "parallel transmission," which uses
multiple lines to transmit several bits simultaneously (8, 16, 32, etc.).
External communications networks use serial transmission.
SOURCE
CODE:
#include<regx51.h>
unsigned char const *dat="HAVE A NICE DAY-GCT";
unsigned int i;
void main(void)
{
SCON=0x40;
TMOD=0x20;
TH1=0xfd;
TL1=0x00;
TR1=1;
while(1)
{
while(*dat)
{
SBUF=*dat;
TI=0;
while(TI==0);
for(i=0;i<=32000;i++);
dat++;
}
}
}
RESULT:
Thus the source code for serial
transmission was
written using Keil and implemented in Proteus and verified.
CIRCUIT SCHEMATIC & OUTPUT:
SERIAL TRANSMISSION &
RECEPTION
AIM:
To develop the source code for serial
transmission and reception using Keil µ
vision and to implement it using Proteus tool.
THEORY:
Serial communication is the process of sending data one bit at a time, sequentially, over a communication
channel or computer bus.
This is in contrast to parallel
communication, where several
bits are sent as a whole, on a link with several parallel channels. Serial
communication is used for all long-haul communication and most computer networks, where the cost of cable
and synchronization difficulties make parallel communication
impractical.
Serial reception is the process of receiving data, one bit at a time
(one bit after the other). Contrast with "parallel reception," which
uses multiple lines to receive several bits simultaneously (8, 16, 32, etc.).
External communications networks use serial transmission and reception.
SOURCE
CODE:
#include<regx51.h>
unsigned int i,temp;
void main(void)
{
SCON=0x50;
TMOD=0x20;
TH1=0xFD;
TL1=0x00;
TR1=1;
while(1)
{
while(RI==0);
RI=0;
temp=SBUF;
for(i=0;i<=10000;i++);
TI=0;
SBUF=temp;
while(TI==0);
for(i=0;i<=20000;i++);
}
}
RESULT:
Thus
the source code serial transmission and
reception is written using Keil and
implemented in Proteus and verified.
LCD AUTO DISPLAY
AIM:
To develop the source code for LCD
auto display using Keil µ vision and to
implement it using Proteus tool.
THEORY:
LCD is a very commonly used output device to display alphanumeric
characters. The LCD displays the character corresponding to the data received
on its input data port i.e., it treats the data as the ASCII value of the
character to be displayed. So if the value 65 is given to its data port the
character “A” will be displayed and if the value 49 is given to the LCD the
numeric digit “1” will be displayed. At many instances it is required to
display a number like 123 on LCD. Displaying this number is tricky. If the data
port of the LCD is loaded with the number 123, then the character corresponding
to it will be displayed
LCD (Liquid Crystal Display) screen is an electronic display module and
find a wide range of applications. A 16x2 LCD display is very basic module and
is very commonly used in various devices and circuits. This LCD has two
registers, namely, Command and Data.
The command register stores the
command instructions given to the LCD. A command is an instruction given to LCD
to do a predefined task like initializing it, clearing its screen, setting the
cursor position, controlling display etc. The data register stores the data to
be displayed on the LCD. The data is the ASCII value of the character to be
displayed on the LCD.
SOURCE
CODE:
#include<regx51.h>
sfr out=0x90;
sbit rs=0xa0;
sbit rw=0xa1;
sbit e=0xa2;
sbit in=0xa3;
sbit out1=0xa4;
sbit out2=0xa5;
sbit out3=0xa6;
sbit out4=0xa7;
void lcd_init();
void lcd_command(unsigned char);
void lcd_data(unsigned char const *dat);
void delay(unsigned int);
void main(void)
{
out=0x00;
rs=rw=e=out1=out2=out3=out4=0;
in=0;
lcd_init();
while(in==0)
{
out1=out2=1;
out3=out4=0;
lcd_command(0x80);
lcd_data("WELCOME");
lcd_command(0xC2);
lcd_data("by
VLSI-GCT");
}
while(in==1)
{
out1=out2=0;
out3=out4=1;
lcd_command(0x80);
lcd_data("Good
Morning");
lcd_command(0xC2);
lcd_data(" Alarm ON
");
}
}
void lcd_init()
{
lcd_command(0x38);
delay(200);
lcd_command(0x06);
delay(200);
lcd_command(0x0c);
delay(200);
lcd_command(0x01);
delay(200);
}
void lcd_command(unsigned char a)
{
out=a;
rs=0;
e=1;
delay(1000);
e=0;
}
void lcd_data(unsigned char const *dat)
{
while(*dat)
{
out=(*dat);
rs=1;
e=1;
delay(1000);
e=0;
dat++;
}
}
void delay(unsigned int x)
{
while(x--);
}
RESULT:
Thus the source code for LCD auto display is
written using Keil and implemented in Proteus and verified.
