Gadgetronicx

Random Number generator using 8051 Microcontroller

Frankpunter@gmail.com (Anonymous) — Fri, 27 Mar 2015 10:15:00 +0530

Random Number generators are something which is used to draw out a random number and use it for a specified purpose. The purpose may differ it might be lottery draw , competition or whatever it may be the above generator using 8051 will do a pretty good job also the complexity level of the program is very simple.

IC 74LS48:

The IC 74LS48 or 7448 is a simple BCD to 7 segment decoder which was used to reduce the usage of pins dedicated to the 7 segment display. It consists of 4 input pins namely 1,2,3,4 which is used to feed 4 bit data input to the IC. The fed 4 bit input binary data in turn decoded by the IC and output is obtained from the pins a, b ..... f which is connected to the corresponding pins of the 7 segment display. This will display the correct digit in the 7 segment display.

DESIGN:

In the above design i have used two 7448 IC to interface two 7 segments in a single port, this will save the pin usage from the microcontroller. You can also go for direct interfacing of a 7 segment with a dedicated port if you don't have 7448 IC in your possession.

Interrupt 0 feature of the Microcontroller was used here, therefore a simple push button was interfaced with the pin INT0 pin of the 8051 controller. Reset button was used with the pin 9 to reset the operation and start running the program from the beginning.

NUMBER GENERATION PROCESS:

Initially the number keeps running from 0 to 99 in the display at high speed in a loop, so it will barely visible to human eye.
Pressing the interrupt button fetches the random number and displays it in the 7 segment display.
The the reset button should be pressed to initialize the program and counting again.

CODE:

This code was built using Keil Uvision 4

#include<regx51.h>
int a,b;
void delay();
void main()
{
IE=0x81; //External interrupt activation
while(1)
{
for(a=0;a<=9;a++) //Number generation
{
for(b=0;b<=9;b++)
{
P2=a|b<<4;
delay();
}
}
}
}
void delay()
{
int i;
for(i=0;i<=400;i++);
}
void extr0(void) interrupt 0 //Subroutine EX0 with interrupt number '0'
{
P2=a|b<<4;
while(1);
}

NOTE:

Resistors for 7 segment are omitted for the simplicity of the schematic diagram, hook up a 470 ohm resistor to each pins connecting from 74LS48 to 7 segment pins.

Electronic Dice Circuit using IC CD4017

Frankpunter@gmail.com (Anonymous) — Sun, 22 Mar 2015 16:40:00 +0530

Dice are very well known in all parts of the world as there are plenty of games played using it. The purpose of dice is to pick a number randomly and play game proceed based on the picked number. But when using primitive dice there is a chance that player can cheat the opposition with spinning techniques. The above provided circuit can be used to avoid cheating since it depends on the push of a button.

WORKING OF CIRCUIT:

The working of the circuit starts with a astable multivibrator using a simple 555 timer IC. This gives out series of clock pulses as output. And the frequency of the output pulse depends of resistor and capacitor connected to the IC 555. You can choose the resistor and capacitor connected to the 555 of your wish but make sure the frequency is high enough to dodge the human eyes.

The IC 4017 forms the next part of this circuit. IC 4017 also known as Johnson counter is capable of counting the incoming pulses fed to its CLK pin and with each increment in clock cycles the high signal output goes from Q0 to Q9. That is during the first positive edge of the cycle the ouput Q0 pin gives logic high and Q1 during the second edge and it goes on till Q9. This logic forms the backbone of the above circuit.

Six LED's are arranged from 1 to 6 where each LED's positions represent the number that can be drawn out of the die. Current limiting resistors of 470 ohm was added to limit the current and protect the circuit from damage.

Initially when the Spin switch is in open state the output of ICC 555 will be high and static. But the moment the button is pressed the LED's started running due to the high frequency input from the 555. And when spin button is released, a random LED's gets lighted and the position of the number represents the number drawn out of the die. And you can play the game with the number drawn from it.

NOTE:

Pick Resistor R1,R2 and C2 is such a way that the output frequency is high and the running of LED's is barely visible to the eyes.

Analog to Digital converter circuit using ADC0808

Frankpunter@gmail.com (Anonymous) — Tue, 17 Mar 2015 20:54:00 +0530

The Analog to digital converters are very useful in a digital system where the conversion of raw analog signal to digital data bits possess a notable significance. ADC's are also quite familiar in several microcontrollers, but using a ADC in micrcontroller requires programming skills and not everyone love to go in to programming. The circuit shown above will offer a solution for those who don't have any sort of programming skills.

IC ADC0808:

This IC was a simple Analog to Digital converter which provides a resulting 8 bit data for input analog signal. The pins OUT1 to OUT8 gives the output data bits in binary form whereas IN0 to IN7 allows user to feed their analog signal. User can use only one input channel at a time and the channel selection was done by using the pins ADDA to ADDC. The various logic states at these three pins will enable us to select one out of 8 different channels.

The ALE (Address latch enable) pin should be made high to enable the selection of input channels. The EOC(End of conversion) and Start pins are used to control the data conversion. The EOC pin gives high state after conversion and the start of conversion can be initiated by feeding the low pulse to the active low Start pin of the IC. The OE(output Enable pin) was used to enable the digitized output and Clock pin to feed the clock pulse for chip operation.

WORKING OF CIRCUIT:

The working of the circuit starts with making ALE and OE pins high which are meant to choose the channel and also enable output. 5 V was the default reference voltage and it can be altered by feeding the voltage of our desire to the pins Vref+ and Vref-. The Channel selection should be done by using the pin ADDA to ADDC pins and here in this circuit diagram input channel 1 was selected. The below table will give the logic states of all pins and their respective channel selection.

Now the Analog signal is fed into the channel you selected and then the state of the pin START should be made low from high to start for activation. And after the conversion the EOC pin goes high and it indicates the conversion is over. The EOC pin retains it low state as soon the next pulse is encountered. As you can see in the above circuit the EOC pin was connected to start pin which triggers a chain reaction resulting in continuous conversion to take place.

Finally we will get a 8 bit data from the pins OUT1 to OUT8 which can be used for further processing and display. You can even connect the LED's to these pins and visually view the output binary data, Led On indicates binary 1 and off indicates binary 0 data.

NOTE:

You can control the data conversion by adding a button to the start button which connects to the ground when pressed.
Adding a indicator LED to EOC pin will help to notify the end of conversion.
Change the combination of switches as per the logic table to select through the various input channels.
Since it was a 8 bit ADC the resulting increment in output data will vary per Vref/256 i.e 2^8.

Creating Pac man custom pattern and animation in LCD display

Frankpunter@gmail.com (Anonymous) — Thu, 12 Mar 2015 11:04:00 +0530

LCD modules are widely used to display calculated data's, user references and much more. In addition all character based LCD which uses HD44780 controller consists of a special RAM known as CGRAM which allows user to create custom patterns. This tutorial will teach you to create your desired pattern as well running it as a simple animation.

DESIGN:

CGROM:

CG ROM is nothing but a memory which holds the pattern of the characters as predefined lcd font. Ever wondered how LCD displays the corresponding font when you pass the ASCII value of a particular character. This job was done by means of this CGROM memory.

DDRAM:

This memory holds the characters which are currently displayed on the screen. That is whenever a character is about to displayed the contents of the CGROM will be loaded to the DDRAM and in this way the characters can be displayed in the screen.

CGRAM:

CGRAM is the memory in the LCD module which allows user to create custom characters by rewriting the character patterns in the program.Generally we will initialize the LCD by using "0x80" command which will point the DDRAM address and from there the LCD allows us to display predefined characters which is stored in the CGROM.

In order to create custom pattern we should initialize the device to point the CGRAM address ranging from 0x00 to 0x07 in the LCD. This can be done by using the command "0x40", which forces the device to point CGRAM address. Refer the instruction set of LCD for better understanding. Remember there is a difference between instruction "0x40" and address "0x00" try not to get confused.

So whenever you writes the instruction 0x40 it will allow us to create the predefined character in the CGRAM address 0x00. The command 0x48 will allows us to store the pattern in the address 0x01. In this way we can create up to 8 character patterns. So we now know what is CGRAM and how to initialize it for storing our custom character. Now lets see how to create the pattern in it.

The above block represents a single elements of an LCD and it contains 5 columns and 8 rows in it. And we are going to create pattern by sending corresponding byte for each row. For example we need to make first three columns to lighten up then we should send "XXX11100" byte to the LCD, the first three bytes are don't care. Next we should do the same for the remaining rows. So after sending 8 bytes of data we will finish up with storing a Custom pattern in the CGRAM address. For next pattern we should move on to the next address with instruction 0x48 and so on.

Here is a Custom generated Pac man icon using a simple web tool. Not to worry it looks lot better while displaying it in the LCD.

So we are now done with the chracter generation and all its left now is to display it. It can be done by using calling the CCRAM address as data in the program lcd_data(0x00,1) will print the pattern you have previously stored in the CGRAM address 0x00 by using the instruction 0x40. And 0x01 will print the pattern you stored using the instrcution 0x48 and so on.

STEPS TO CREATE PATTERN :

Initialize the LCD as you do it generally.
Pass the command 0x40 to point the CGRAM address.
Now create your desired custom pattern by using the above method.
After finishing your pattern return to the DDRAM location by giving the command 0x80 to the LCD.
And now print the pattern in any location by passing the CGRAM address 0x00,0x01 to 0x07 as data (i.e with RS pin high state) to the LCD.
You will get your pattern now.

ANIMATING THE PATTERNS:

Animating the patterns is not a big task create some of your desired patterns and program it to display the patterns in a sequence and you will get your animation. For example i have created two patterns of Pac man one is normal icon and another one is with its mouth wide open. All i am going to do it display these two patterns one by one in a sequence with specific delay. Through this am going to make it look like eating out the word "WELCOME" in the lcd, Sounds cool isn't it.

CODE:

This code was built using AVR studio. You can built this LCD animation using any controller 8051,PIC, ARM etc by following the pattern creation logic.

#include<avr/io.h>
#define F_CPU 8000000UL
#include<util/delay.h>
unsigned char font1[8]={0x0F,0x1E,0x1C,0x18,0x18,0x1C,0x1E,0x0F};
unsigned char font2[8]={0x0E,0x1F,0x1B,0x1F,0x1C,0x1F,0x1F,0x0E};
unsigned char word2[]={"WELCOME"};
int i;
char position;
void lcd_data (char a,int b) //LCD routine for data and command
{
PORTA=a;
if(b==0)
{
PORTB&=~(1<<0);
}
else
{
PORTB|=(1<<0);
}
PORTB|=(1<<1);
_delay_ms(2);
PORTB&=~(1<<1);
_delay_ms(2);
}
void lcd_init ()
{
lcd_data(0x3C,0); // 4-bit mode - 2 line - 5x10 font.
lcd_data(0x0C,0); // Display cursor with blink.
lcd_data(0x06,0); // Automatic Increment - No Display shift.
lcd_data(0x01,0);
lcd_data(0x02,0); //Clear screen and return home
}
int main()
{
DDRA=0xff;
DDRB=0x03;
lcd_init();
lcd_data(0x40,0);
for(i=0;i<=7;i++)
{
lcd_data(font1[i],1);
}
lcd_data(0x48,0);
for(i=0;i<=7;i++)
{
lcd_data(font2[i],1);
}
lcd_data(0xc5,0);
for(i=0;i<=6;i++)
{
lcd_data(word2[i],1);
}
i=0;
position=0xC4;
while(i<=6) //Pac man eating out the letters animation sequence
{
lcd_data(position,0);
lcd_data(0x01,1); //Displaying first pattern
_delay_ms(150);
lcd_data(position,0);
lcd_data(0x00,1); //Displaying second pattern with delay
_delay_ms(300);
lcd_data(position,0);
lcd_data(' ',1);
i++;
position++;
}
lcd_data(0x01,1);
return 0;
while(1);
}

WORKING VIDEO:

NOTE:

Use 5x10 matrix to use the complete pixel for your pattern.
Specify appropriate time delay when running your pattern as an animation.
Working video of this animation will be added shortly.

Musical Greeting Card circuit using UM66 IC

Frankpunter@gmail.com (Anonymous) — Fri, 6 Mar 2015 09:14:00 +0530

Musical greeting cards quite are popular during special occasions all around the world and we all would have presented this thing to our dear ones. But ever tried making one by your own if not, its time to build one. Here is a simple Musical greeting circuit you can try out easily in your home, also the cost required to build this thing is pretty low.

SCHEMATIC:

UM66TXX SERIES IC's:

The UM66TXX is a simple CMOS IC which was designed specifically to be used in this kind of simple melody/tone generation circuits. It consists of a on chip ROM programmed with particular music or tone and named based on the tone. Since it was produced by using CMOS technology it consumes only less power which proves to be a great advantage. Here is the list of IC's with programmed tones.

UM66T01 - Jingle bells + Santa is coming to town + We wish you a merry xmas
UM66T02 - Jingle Bells
UM66T04 - Jingle Bells + Rudolph the red nosed reindeer + Joy to the world
UM66T05 - Home sweet home
UM66T06 - Let me call you Sweetheart
UM66T08 - Happy Birthday to you
UM66T09 - Wedding march
UM66T11 - Love Me Tender, Love me True
UM66T13 - Easter Paradise
UM66T19 - For Elise
UM66T32 - Waltz
UM66T33 - Mary Had a little Lamb
UM66T34 - The train is Running fast UM66T68

USE OF REED SWITCH:

You might have seen that musical greeting card uses leaf or slider switch which activates the toner when you open it. The major problem with those type of switches is that the link gets weaker with time due to usage and gradually the circuit gets activated even when the card is in closed position. This will be annoying most of the times.

To overcome the above drawback reed switch was used here which uses magnetic force for activation. So there won't be any undesirable activation of the tone generator part in our circuit. Place the magnet in one side of the card and the rest of the circuit in opposite side. Make sure that magnet touches the reed switch when the card is closed.

WORKING OF CIRCUIT:

The working of the circuit begins with the Reed switch which gets activated whenever it comes in contact with a magnet. Affix the magnet in one side of the card and the entire circuit is other side of your card. When the card was in closed state, reed switch will be in closed state and this makes the base of the PNP transistor to be in positive potential i.e more than 0.7 v which forces it to off state.

Opening of the card will force the magnet to break its force of attraction and the reed switch will be in open state now. Then the resistor R2 will pull the base to ground potential. This makes the PNP transistor Q2 2N3906 to switch on and this in turn turns the IC UM66T08 on.

When the IC is turned on The output of IC was fed in to the base of the NPN transistor Q1 and this supplies the required current for the sounding element to operate. Finally we can get our desired tone/melody from the piezo sounder. In the above circuit IC UM66T08 was used which contains "Happy Birthday to you" tone programmed within it.

NOTE:

You can use the primitive leaf or slider switch with the above circuit instead of reed switch, in that case eliminate R1,R2 and Q2 and connect the switch end directly to the VCC pin of the IC.
Make sure that the magnet and switch was placed in such a way that it touches each other when the card is closed.
The above circuit generates "Happy Birthday tone", however if you need any other tone choose the respective UM66TXX IC from the above given list.

Vertical Flip with Caption display using CSS and HTML

Frankpunter@gmail.com (Anonymous) — Fri, 27 Feb 2015 20:39:00 +0530

Captions play a significant role in almost all the pictures in a website. So it is important to add one to our images and will be even cooler if we add it along with a hover effect. This article will demonstrate demonstrate the method of adding caption to your image with a vertical flip hover effect.

VIEW DEMO

CSS CODE:

#card {
width:250px;
height:250px;
position:relative;
-webkit-transform-style: preserve-3d;
-webkit-transform-origin: 100% 75px;
-webkit-transition: all 0.7s ease;
transform-style: preserve-3d;
transform-origin: 100% 75px;
transition: all 0.7s ease;
}
#frame:hover #card {
-webkit-transform: rotateX(-180deg);
transform: rotateX(-180deg);
}
#front_pos, #back_pos {
width:250px;
height:250px;
position:absolute;
left:0;
-webkit-backface-visibility:hidden;
backface-visibility:hidden;
}
#back_pos {
position:absolute;
bottom:170px;
font-size:30px;
color:#fff;
-webkit-transform: rotateX(180deg);
transform: rotateX(180deg);
text-align:center;
}

The property "transform:rotateY(-180deg)" flips the front image to 180 degree revealing the image in the back when the container is hovered. "backface-visibility:hidden" is used to hide the alternate image so that a single image is displayed at an instant. The "#front_pos" and "#back_pos" defines the properties of the image before flipping and after flipping.

HTML CODE:

<div id="frame">
<div id="card">
<img id="front_pos" src="Your image URL" alt="img"/>
<p id="back_pos">Your text</p>
</div>
</div>

The HTML part of this code is pretty straightforward. All you have to do is to place the elements in "div" container with respective ID's.

60W simple inverter using Transistors

Frankpunter@gmail.com (Anonymous) — Sun, 22 Feb 2015 18:21:00 +0530

Inverters are handy piece of equipment we could use whenever we face a power shut down or in a place where wiring is not possible. There are many types of inverters available in market from cheap one to expensive ones. Each differ with their functionality and the load they could handle. This tutorial brings out the design to build a simple inverter using transistors.

WORKING:

Astable multivibrator using transistor will form the backbone of the above circuit. The complementary pulse output and the normal pulse is fed into the darlington pair of transistors formed by Q3 & Q4 and Q5 & Q6 . In darlington pair two transistors was connected in such a way current amplified by the first transistor is further amplified by the second one. Two dalrington pairs was used here since the current given the multivibrator is very less.

The signal from the darlington pair of transitsors was then fed to transistors Q7 and Q8 which was wired in push pull configuration. Each of the transistor Q8 and Q7 will amplify the positive and negative half cycles of the input wave. The amplified output is then fed to the transformer and then to the load.

As the astable multivibrator switches back and forth, it alternately turns on the two power transistors. The current in the transformer flows from the tap to the ends of the windings in opposite directions, causing the output to the desired AC. The current flows from +12V, through the windings, through the power transistors to ground.

12V center tapped transformer was used in this circuit. The current rating of the transformer can be chosen based on the load you are about to use along with this circuit. Heatsinks can be added along with the output stage transistors to avoid overheating. This inverter is also called digital inverter since it was driven by square wave rather than by using a sine wave.

4 Bit LCD interface and programming with PIC Microcontroller

Frankpunter@gmail.com (Anonymous) — Thu, 19 Feb 2015 20:56:00 +0530

LCD displays operate in two modes 4 bit and 8 bit mode. We all might have been familiar with 8 bit mode which is used widely in several systems. But 4 bit mode is something which many of us is not aware of. This mode has some advantages over the 8 bit mode out of which reduction of dedicated data pins is most important. This tutorial will teach you to interface the LCD in 4 bit with your controller as well as programming it.

WHAT IS 4 BIT MODE:

We all knew that LCD consists of 8 data pins D0-D7 to receive the data and commands from the Microcontroller. However when developing a complex systems dedicating a complete port i.e 8 pins might be a drawback. To overcome this the LCD controller is capable of running in dual modes 8 bit and 4 bit mode.

8 Bit mode is a normal mode which uses 8 data lines, rs and enable for lcd functioning, see programming LCD in 8 bit mode. However in 4 bit mode only 4 lines D4-D7, along with RS,RW and EN pins are used. This will save us 4 pins of our controller which we might employ it for other purpose.

In 4 Bit mode the data bytes are sliced into two four bits and are transferred in the form of a nibble. And the rest of the pin functions such as RS,RW and EN remains same. The above design illustrates the connection diagram of a 16x2 LCD with PIC microcontroller in 4 bit mode.

INITIALIZING THE LCD:

The first step in coding the LCD is initializing the LCD connected by giving the commands as input through the data line D4-D7 in the fom of Nibbles. For initializing the LCD following a specific reset sequence should be given and then initialized to follow the 4 bit mode.

Place the byte in D4-D7 pins of LCD and set the EN pin to high and then make it low with time delay of 10ms between them.
Send 28H command to use 2 lines 5x7 matrix in 4 bit mode.
Send 0FH for making the LCD,cursor and Cursor blinking ON.
Send 06H for incrementing cursor position.
Finally 01 and 02 for clearing screen and returning home.

DATA/COMMAND TRANSMISSION TO THE LCD:

The data transmission to a LCD must be performed by means of assigning logic states to three pins RS and E. R/W pin is not needed so we can ground it as shown in the schematic diagram. The data is send to the module by following these steps.

RS pin should be high to convey LCD a data transmission is going to take place.
Place the Upper nibble in the lower four bits of Port 2 by means of bit shifting and mask the upper four bits.
Pulse En pin from high to low with certain time delay for transmission to complete.
Now place the lower nibble and mask the rest of the bits, then repeat step 3.

CODE:

This code was built using CCS compiler for PIC microcontroller.

#include <4_bit_lcd.h>
#byte LCD=0x08
#byte TRIS_LCD=0x88
#define ENABLE 0x20
#define REG_SL 0x10
void lcd_reset() //Reset sequence as stated in the LCD datasheet
{
LCD = 0xFF;
LCD = 0x03|ENABLE;
delay_ms(2);
LCD = 0x03;
delay_ms(2);
LCD = 0x03|ENABLE;
delay_ms(2);
LCD = 0x03;
delay_ms(2);
LCD = 0x03|ENABLE;
delay_ms(2);
LCD = 0x03;
delay_ms(2);
LCD = 0x02|ENABLE;
delay_ms(2);
LCD = 0x02;
delay_ms(2);
}
void lcd_cmd(char cmd) //Subroutine to send command
{
LCD = ((cmd>>4)&0x0F)|ENABLE;//Sending higher nibble by shifting with Pulsing ENABLE high delay();
delay_ms(2);
LCD = ((cmd>>4)&0x0F);
delay_ms(2);
LCD = (cmd & 0x0F)|ENABLE;//Sending lower nibble ENABLE low
delay_ms(2);
LCD = (cmd & 0x0F);
delay_ms(2);
}
void lcd_data (char *dat) //Subroutine to send data
{
while(*dat!='\0')
{
LCD = ((*dat>>4)&0x0F)|0x30;
delay_ms(2);
LCD = (((*dat>>4)&0x0F)|REG_SL);
delay_ms(2);
LCD = ((*dat & 0x0F)|ENABLE|REG_SL);
delay_ms(2);
LCD = ((*dat & 0x0F)|REG_SL);
delay_ms(2);
dat++;
}
delay_ms(2);
}
void lcd_init ()
{
lcd_cmd(0x28); // 4-bit mode - 2 line - 5x7 font.
lcd_cmd(0x0F); // Display cursor with blink.
lcd_cmd(0x06); // Automatic Increment - No Display shift.
lcd_cmd(0x01);
lcd_cmd(0x02); //Clear screen and return home
lcd_cmd(0x80); // First row first column
}
void main()
{
char msg[]="GADGETRONICX";
TRIS_LCD=0x00;
lcd_reset();
lcd_init();
lcd_data(msg);
while(TRUE);
}

NOTE:

The delay required by the LCD for processing data and command depends on the LCD. So in case if you face any trouble in displaying character on LCD try increasing the delay between the enable pulse.

Code lock circuit using dual flip flop IC CD4013

Frankpunter@gmail.com (Anonymous) — Sun, 15 Feb 2015 16:06:00 +0530

Electronic Locks are highly useful to protect our possession and it was widely used in all places. The demand for Electronic locks is high since it offer high security and easy to handle rather than the mechanical locks. Most of the E-locks in the market are cost more and not everyone could afford buying these locks. The circuit above can be a best solution for those who want to build an effective and low cost Electronic lock.

WORKING OF CIRCUIT:

This code lock circuit was build around two D type Flip Flops IC's CD4013. The operation of a single D type Flip flop unit is very important to understand the working principle of the above circuit. The operation of a D type Flip flop is as follows: Any input appearing at the data input D during present state will appear at pin Q during the next clock cycle. This operation principle forms backbone of the above code locker. The below truth table of IC CD4013 might give you the idea of its working.

In the above circuit the Switches 1,3,5,8 are wired to feed the clock pulse to each flip flop units U1:A,U1:B,U2:A and U2:B. Therefore the password for the above locker is "1358" and should be pressed in the given sequence. Now take a look at the first state of the given table where it was stated that when positive edge clock was fed in to the CLK pin of the IC when Data pin D was in low 0 state will result in Low and high state in Q and Q' pins of the IC. This state was used in the whole circuit.

Initially D pin of the U1:A is grounded and this in turn gives low output at pin 1 Q when positive edge is encountered in the CLK pin of U1:A by pressing switch 1. The Pin 1(Q) was wired to the Data pin 9 of U1:B, this will place the low signal in it. When switch 3 is pressed the positive edge clock is fed to U1:B, this will force the Q pin of U1:B to exhibit low state which was fed in its data input. This process will continue as you press 5 and 8 switches. Finally after switch 8 is pressed the Q pin 13 of U2:B will gives a low signal which in turn turns the PNP transistor ON and therefore the relay gets activated.

When anything other than the Password switches "1358" is pressed Q pin of the all the flips flops will obtain high 1 state as shown in the above table. Therefore the locker will remain in lock state. Pull down resistors R2,R3,R4 and R5 was used to ensure that the CLK pin was in low state before feeding the input pulse. A diode was added along with the relay to prevent the reverse flow of current which might damage the IC.

NOTE:

You can change the password sequence by appropriate wiring to the CLK pins of each flip flop units.
The VDD(power) and VSS(ground) pins of the IC was omitted for simplification of the schematic.
Sometimes the IC 4013 may not start with high state on start up, in that case add a power on reset circuitry to the reset pins of flip flops.

How to build a multiple effect lighting circuit

Frankpunter@gmail.com (Anonymous) — Sun, 8 Feb 2015 17:38:00 +0530

LED lighting have a great demand since it consumes less power also have a increased life time. Also LED allows us to create beautiful lighting than the normal ones. Here is a similar lighting circuit which uses the concept of PWM to alter the LED lighting rate which in turn gives multiple lighting effects and be used to decorate your home.

CIRCUIT DESIGN:

WORKING OF CIRCUIT:

555 Timer IC forms the center piece which was wired as a simple astable multivibrator in the above circuit. We all are aware that the astable mutivibrator gives out square pulse as output. The frequency, time period and duty cycle of the pulse was decided by the three Key components R1, R2 and C2. These components affects the capacitor charging rate and time taken to switch output states in a timer IC.

PWM signal

This is where the PWM is employed which alters the duty cycle of the output pulse. Duty cycle defined as the time period in which the signal is active, expressed in percentage (%). Altering the duty cycle will provide variation in LED on times and this provides a beautiful lighting effect. The duty cycle of the 555 was governed by the equation

Duty Cycle = (R1+R2) / (R1+2R2) %

The above circuit was provided with a simple single pole triple throw rotary switches which allow us to alter the duty cycle with ease. According to the equation given above the R1 and R2 decides the duty cycle fatcor in the outout pulse. So when R1=200 ohm and R2=5K the duty cycle will be

Duty cycle = (200+5K)/(200+2(5K))= 50 %

Likewise 2.7K and 10K of R1 will result in 60 and 70 percentage of duty cycle. Capacitor C2 can be changed if you need to alter the frequency of the output waveform.

Next comes the lighting stage, the output of the 555 is not enough to drive many LED's to produce the lighting. So transistors was used as a switch to turn ON the LED's connected to it. Two transistors NPN and PNP was used in the above circuit to make the lighting effect even cooler.

The NPN transistor & the LED's connected to it turns on whenever there is a high pulse from the 555 and it will stay on as long as the high pulse remains. And when the 555 switches its state to low the transistor Q1 and led's connected to it turns off but PNP transistor Q2 and led's connected to it gets lighten up producing a beautiful lighting effect.

The circuit is capable of producing effects like wave, disco and lots more. Try wiring the LED's in different patterns to get even cooler lighting effects.

NOTE:

You can increase add or change resistors R1 based on the calculations to obtain altered duty cycle in the output.
Additional capacitors C2 and rotary switches can be added to get altered frequency in the output.
Multiple combination of LED's can be used in the above circuit.

Interfacing Bluetooth module HC05 with 8051 Microcontroller

Frankpunter@gmail.com (Anonymous) — Wed, 4 Feb 2015 10:30:00 +0530

Bluetooth technology creates a big evolution in way the devices communicate with each other. So it is important to learn interfacing Bluetooth with our MCU's to build extended system also it offers facility to wireless control. This tutorial focuses in interfacing Bluetooth module HC05 with 8051 microcontroller.

At the end of this tutorial you will be able to:

- Program and interface Bluetooth module with 8051

- Send and receive data's using 8051 via Bluetooth.

- Build and control any system using Bluetooth devices such as mobile phone ,PC, tablets etc.

HC05:

A Bluetooth module widely used with Microcontroller to enable Bluetooth communication. This module cam be interfaced using the UART in 8051 microcontroller where the data are transmitted in the form of packets. The pins TX and RX pin of the HC 05 form the path for data transmission and reception. These TX pin of HC05 must be connected to the RX pin of 8051 and vice versa. Whereas the key pin of the module is used to set the password for pairing the module with our devices.

DATASHEET

APPLICATION:

Snapshot of BT terminal Application

Our devices such as mobile and PC's need special applications known as "Bluetooth Terminal" to communicate with our microcontrollers via Bluetooth. Not to worry, there are plenty of apps you can find in the internet. These apps are available in plenty irrespective of the you device OS Android, Windows , Mac whatever it may be. Just run a search such as Bluetooth Terminal for "OS name" and search engines will take you to the destination.

These applications are developed in such a way to send characters through your device BT which was received by the BT module connected with our controller. Even some apps offers some interactive GUI buttons which transmits specific characters with the press of each buttons. Later the received character can be processed in our code and force the controller to perform tasks based on the received character. We can use the Bluetooth communication in two ways, either we can use it to receive data from the Controller or control the system using our device Bluetooth.

DESIGN:

STEPS TO PROGRAM:

This uses Serial Communication or UART protocol in the 8051 , so those who are not familiar with this kindly go through this article on "UART tutorial in 8051" and "UART interrupt" before getting started with BT interface.
Initialize the Serial communication in 8051 using Timer and serial registers.
Generate the required baud rate for the communication to take place. The default baud rate of the HC05 is 9600.
Initialize serial interrupts in case you need to control the tasks performed by your microcontroller or receive data when requested.

SAMPLE CODE:

The below code was built using Keil uVision 4.

FOR RECEIVING DATA FROM CONTROLLER VIA BT:

Here a specific data can be transmitted whenever a interrupt request occurred from our device via bluetooth. In the below code a processed data was transmitted to our device from the controller when a serial interrupt occurs.

#include<regx51.h>
int a,b,ans;
char data[4];
void main()
{
a=80;
b=40;
ans=a+b;
sprintf(data, "%d", ans);
TMOD=0x20; //Choosing Timer mode
TH1=0xFD; //Selecting Baud Rate
SCON=0x50; //Serial mode selection
TR1=1;
IE=0x90; //Enabling Serial Interrupt
while(1);
}
void ser_intr(void)interrupt 4 //Subroutine for Interrupt
{
IE=0x00;
short int i;
for(i=0;i<=2;i++) //Transmitting data
{
SBUF=data[i];
while(TI==0);
TI=0;
}
IE=0x90;
}

CODE FOR CONTROLLING CONTROLLER TASKS VIA BT:

Here a specific task is performed on interrupt occurence in the controller via BT. Consider a Motor was connected in P2.0 & P2.1 of the controller and we are about to control its direction of rotation via BT from our device. Sending character "F" will make the motor to rotate clockwise whereas "R" will make the motor to rotate in anti clockwise direction.

#include<regx51.h>
sbit mot1=P2^0;
sbit mot2=P2^1;
void main()
{
//////////
Initialize serial communication and activate interrupts.
//////////
}
void ser_intr(void)interrupt 4 //Subroutine for Interrupt
{
char c;
IE=0x00;
while(RI==0);
c=SBUF;
if(c=='F'); //Controlling motor
{
mot1=1;
mot2=0;
}
else if(c=='R')
{
mot1=0;
mot2=1;
}
IE=0x90;
}

Hope you like this tutorial, leave your queries and feedback in the below comment box.

Ultrasonic receiver circuit using Opamp LM324

Frankpunter@gmail.com (Anonymous) — Fri, 30 Jan 2015 10:44:00 +0530

Ultrasonic sound waves are high frequency waves which is inaudible to human ear. It also had hell lot of applications in this world like range detection,machinery flaw detection etc. This circuit demonstrates the building of ultrasonic wave receiver which matches with the transmitter which was published previously in our site.

Ultrasonic Receiver circuit

WORKING:

This circuit uses a simple ultrasonic receiver ( transducer) which converts the incoming ultrasonic wave to equivalent voltage. The signal was then passed through a non inverting amplifier built using Quad Op amp IC LM324. The gain of the amplifier can be controlled using a feedback resistor R3 connected from output to the inverting terminal.

Then this signal is further passed to the next stage of non inverting amplifier. There the signal was further amplified and the output was obtained from the pin 7 of the LM324 IC . The signal is then rectified using a diode and passed through a Resistor R5 and Capacitor C2 to prevent the false triggering in the output.

Final stage of the op amp was wired as an comparator which gives high output when ever a ultrasonic wave is detected by the transducer and low signal whenever there is no wave detected by the transducer.

This circuit along with the transmitter can be used to build simple robots in which it will assist the robot to evade the obstacles lying ahead them. Also can be used in range detection when used with a Microcontroller.

Ultrasonic transmitter circuit using IC 555

Frankpunter@gmail.com (Anonymous) — Thu, 22 Jan 2015 11:47:00 +0530

Ultrasonic waves are defined as the sound waves whose frequency is greater than 20Khz and it is not audible to the normal human ears. This ultrasonic possess wide variety of applications from industries (to detect flaws in machineries ) to medicine(for treating and detecting ailments). In fact some animals like Bats, dolphin etc uses these waves to interact with the external environment. This circuit demonstrate constructing a simple 40KHz ultrasonic transmitter built around timer ic 555.

WORKING:

The IC 555 was wired to work as an astable multivibrator which forms the oscillator part of the above circuit. This IC U1 was configured to produce a continuous serial square wave pulses of 40KHZ. And the output frequency was governed by the equation F= 1..44/((R2+2R1)C2) . In the above circuit the components R1,R2 and C2 was selected to give 40KHZ square wave as output.

ULTRASONIC TRANSDUCER:

This is the main component of the above circuit which is responsible for converting the input pulse to Ultrasonic waves of equivalent frequency. Usually it was made up of Piezoelectric crystals which have the property of changing size when voltage is applied. Apply input signal will cause them to oscillate and in turn produces high frequency sound waves. Also some components adapt other methods to produce ultrasonic waves. You can also buy one of these in ebay.

The transistor 2N2222 was used to drive the transducer used. You can also replace the 555 oscillator with oscillators built around crystals for long sustained oscillations.

PCB DESIGN:

DESIGN ( RED LINE - TOP COPPER)

BOTTOM VIEW

TOP VIEW

Clap activated light circuit

Frankpunter@gmail.com (Anonymous) — Wed, 14 Jan 2015 08:27:00 +0530

Clap activated circuits are something which is used to activate or turn on by means of a simple clap. You might have seen some of this before but building one could be really fun. This clap activated switch circuit can be used for any means of activation not just to turn on the lights. Let's look into the working of this cool circuit.

WORKING OF CIRCUIT:

The working of this circuit starts with Microphone which is used to sense the clap. The output of the Microphone was fed into a non inverting pin 3 of a simple operational amplifier. While a voltage divider network using R2 and RV1 provides the reference voltage for the non inverting pin 2 of the op amp.

Clap generally occurs in a short burst of time with high pitch, hence it results in a peak voltage across the pin 3 of the op amp over a short interval of time. So adjust the reference voltage of the non inverting pin accordingly so that the circuit activates only when senses a clap and not to other speech signals.

Now when no clap is sensed there will no voltage across the pin 2 hence output of the op amp remains in low state. A pull down resistor R3 was used to make sure that the pin 6 stays low in the absence of any input signal. When a clap is sensed the output of the Op amp goes high and feeds a positive high output to the flip flop connected to it.

A simple JK flip IC 74109 was used as an activator here where it was wired to toggle it's output state with every edge of the high input. So whenever a clap is sensed the output of the op amp triggers the flip flop and activates the relay by means of a transistor switch. This state will remain until another clap is sensed and the flip flop will toggle its output state (i.e turn off the relay/light) as soon it encounters another clap.

A simple LED with a current limiting resistor was added for indication and a 5V relay was used as an activator here for the light. You can replace the light with the thing you desire to activate it on a clap.

NOTE:

The clap activation must be done with the trial and error method by adjusting the VR1 until the light gets activated with just clap.
Make sure your switching transistor Q1 current rating is good enough to handle the relay.
You can use any Op-amp and JK flip flop IC here.

How to program I2C protocol in ARM Microcontroller

Frankpunter@gmail.com (Anonymous) — Sun, 11 Jan 2015 12:33:00 +0530

I2C (Inter Integrated Circuit) also known as TWI (Two wire Interface) is a bus interface connection that is used in many devices such as Sensors, RTC and EEPROM. Unlike SPI this protocol only uses two wires to establish the connection and hence known as Two wire interface. This protocol will come in handy when the designer needs to conserve the number of pins used to perform the communication. This tutorial will teach you to program I2C protocol in ARM7 Microcontrollers.

I2C PROTOCOL:

This protocol uses 2 bidirectional open drain pins SDA and SCK for data communication. SCL( Serial Clock) is used to synchronize the data transfer between these two chips and SDA to transfer the data to the devices. Therefore this protocol will allow us to reduce communication pins, package size and power consumption drastically. Each devices connected to the I2C line is known as nodes and the communication lines should be activated by means of a pull up resistor.Each data bit is transferred on the SDA line is synchronized by a high to low pulse clock on the SCL line. And the data line cannot change when the clock line is low.

START AND STOP CONDITIONS:

I2C communications are initiated and terminated by means of a START and STOP Conditions. START condition is generated by a high to low change in SDA line when SCL is high wheras STOP condition is generated by low to high change in SDA line when SCL is low.

SLAVE ADDRESSING:

In I2C each slave device should possess an unique address which will be used by the master to address the slave and transmit the data to it. Usually the communication begins with start condition followed by the slave address of the slave and then comes the data.

I hope i have enough information to get you started with I2C, but i advise you to go through this article I2C bus specification to get a deeper understanding in its working and addressing schemes.

REGISTERS USED:

I2CONSET: I2C control register is an 8 bit register which holds the holds the bits to control the I2C communication.

I2STAT: This is an 8 bit read only register which contains the key information and status of the I2C register. The bits in these registers must be checked periodically.

I2DAT: This register holds the data to be transmitted or received. This register can be accessed only when the SI bit is set.

I2ADR: This register holds the slave mode address and used only when the I2C is set to the slave mode.

I2SCLH & I2SCLL: The values in these two registers will be used to set the data rate of the I2C communication. The bit frequency is given the formula

Bit Frequency = Fclk / (I2SCLH+I2SCLL)

I2CONCLR:

I2C control clear register used to clear the controls of the I2C set using the I2CONSET register.

STEPS TO PROGRAM I2C:

MASTER MODE:

Load the values in the I2SCLH and I2SCLL register to set the required bit frequency.
Enable the I2EN bit in the I2CONSET register.
Set the Acknowledgement bit and start bit in the I2CONSET register.
Check for the status 0x08 in the I2STAT register which was defined in the datasheet.
Transmit the slave address, followed by the databytes.
Send the stop signal by activating the bit STO in the I2CONSET register.
Disable the I2C by writing 1 to the bit I2EN in the I2CONCLR register,

SLAVE MODE:

Slave address register should be loaded with the slave address.
The I2EN bit must be set to enable the I2C function and AA bit must be set to acknowledge general address or call address.
Receive or transmit data based on the direction bit received along with the slave address.

Kindly refer the datasheet for all modes of program, since the topic is vast and cannot be covered within this article. Also datasheet did an exceptional job in explaining the registers and modes of I2C operation. The link to download the datasheet is available below.

DATASHEET DOWNLOAD

SAMPLE CODE:

This sample code gives you an idea of programming I2C and transmitting bytes of data in master mode and the slave controller retrieves it and displays it in its Port1. This code was built using Keil uVision 4.

#include<lpc21xx.h>
#define AA 2
#define SI 3
#define STO 4
#define STA 5
#define I2EN 6
void wait(unsigned int delay)
{
while(delay--);
}
void i2c_init(void) //I2C initilaization
{
I2SCLH=100; //Bit frequency calculated value
I2SCLL=100;
I2CONSET=1<<I2EN;
}
int i2c_start() //I2C communication start
{
I2CONCLR=1<<3;
I2CONSET=1<<STA;
while(!(I2STAT==0x08));
return 0;
}
int i2c_write(unsigned char buff) //Data writing through I2C
{
I2CONSET|=1<<SI;
I2DAT=buff;
wait(5000);
I2CONCLR=1<<SI;
wait(5000);
return 0;
}
void i2c_stop(void) //Stop the I2C communication
{
I2CONSET=(1<<STO);
I2CONCLR=(1<<I2EN);
}
int main(void)
{
VPBDIV=0x02; //Setting FCLK frequency
PINSEL0=1<<4|1<<6; //Selecting I2C communication pins
i2c_init();
i2c_start();
i2c_write(0x00);
i2c_write('A');
i2c_write('B');
i2c_write('C');
i2c_stop();
while(1);
}

NOTE:

The Bit rate frequency of the I2C must not exceed 400KHZ so make the calculation to follow this criteria.
Make Changes in the above code as stated in the steps for slave mode to obtain the code for slave controller.
Pull Up resistors should be used to activate the communication lines.

Simple Voting Machine using 8051 Microcontroller

Frankpunter@gmail.com (Anonymous) — Fri, 2 Jan 2015 09:27:00 +0530

Voting or polling machines is one of the finest example for the application of a Microcontroller. This project brings you the design and programming of building a very simple, cost effective polling machines which can do great job for elections in schools, colleges or particular locality. The highlighting feature of this system is that the results of the poll can be viewed instantly also can be monitored from time to time over the period of the poll.

This voting machine was built around 8051 Microcontroller which uses 8 push buttons Poll 1 to Poll 8 which was assigned for a total of eight candidates in this design. To avoid multiple votes by the pollers a poll control switch was added which should be controlled by the supervisor of the poll. A LCD was used to display which candidates they have voted. And at last Hyperterminal should be used with the microcontroller to see poll results using serial communication.

DESIGN:

The poll Poll 1 to Poll 8 switches was scanned from the Microcontroller for casting vote to the respective candidates. But at first Poll control switch must be pressed to make the Poll switches available for voting. So every time a vote is casted the control switch must be pressed in order to allow the next candidate to vote. This avoids multiple votes from the pollers. The Poll control switch was monitored by means of external interrupts.

A LCD was used to display the status of the voting machine i.e whether it is ready to take the next vote or needs to be initialized by the poll control. Also it will display the candidate name once a vote is casted. The vote results can be obtained by using a hyperterminal in a computer connected with 8051, this was done by using the concept of serial interrupts. Any button press in the keyboard will create interrupt and the vote results will be send to the computer in order starting from candidate 1 to candidate 8.

If you are not aware of programming interrupts in 8051 kindly read " External interrupt programming in 8051" & "Serial Interrupt programming in 8051".

VOTING PROCESS:

In order to make this more clear here is the step by step working of this voting machine.

Poll Control switch must be initialized first, then the Microcontroller will be ready to take inputs from the input switches and "CAST YOUR VOTE" message will be displayed in the LCD.
Votes can be now casted using the Poll switches Poll 1 to Poll 8.
After voting a message 'VOTED:CANDIDATE" will be displayed in the LCD.
Now the Poll control switch must be pressed again in order to allow next one to cast their vote, this allows the Supervisors to control the votes.
The results of the poll can be obtained in the computer screen with a single press of any key in the keyboard.

CODE:

This code was built using Keil uVision 4.

#include<reg52.h>
#include<stdio.h>
sbit rs=P3^6;
sbit en=P3^7;
int i,j,k;
unsigned char init_msg[]="Cast Your Vote";
unsigned int votes[8];
void delay() //Delay Subroutine
{
int k;
for(k=0;k<=1000;k++);
}
void lcd(char a,short int b) //Subroutine for displaying characters in LCD
{
P1=a;
rs=b;
en=1;
delay();
en=0;
}
void msg(char *x) //Subroutine to display messages
{
while(*x)
{
lcd(*x++,1);
}
}
void vote() //Subroutine to scan the keypad for vote input
{
while(1)
{
if(P2==0xfe)
{
P2=0x00; //Disabling the port after single press to avoid multiple votes
votes[0]++; //Increment vote value for specified candidate
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE1");
}
if(P2==0xfd)
{
P2=0x00;
votes[1]++;
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE2");
}
if(P2==0xfb)
{
P2=0x00;
votes[2]++;
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE3");
}
if(P2==0xf7)
{
P2=0x00;
votes[3]++;
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE4");
}
if(P2==0xef)
{
P2=0x00;
votes[4]++;
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE5");
}
if(P2==0xdf)
{
P2=0x00;
votes[5]++;
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE6");
}
if(P2==0xbf)
{
P2=0x00;
votes[6]++;
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE7");
}
if(P2==0x7f)
{
P2=0x00;
votes[7]++;
lcd(0x01,0);
lcd(0x80,0);
msg("VOTED:CANDIDATE8");
}
}
}
void serial(void) interrupt 4 //Subroutine for serial interrupt/ To obtain poll results
{
short int i,j;
char c[10];
IE=0x00; //Disabling interrupts to avoid recursion
for(i=0;i<=7;i++) //Loop to send vote results one by one
{
sprintf(c,"%d",votes[i]);
while(c[j]!='\0')
{
SBUF=c[j++];
while(TI==0);
TI=0;
}
SBUF=0x20;
while(TI==0);
TI=0;
j=0;
}
SBUF=0x0D;
while(TI==0);
RI=TI=0;
IE=0x94;
}
void isr_ex1(void) interrupt 2 //Subroutine for external interrupt/To activate poll switches
{
short int y;
P2=0xff; //Activating port 2 for poll inputs
lcd(0x01,0);
lcd(0x38,0);
lcd(0x0f,0);
lcd(0x80,0);
delay();
for(y=0;y<=13;y++)
{
lcd(init_msg[y],1);
}
}
void main()
{
TMOD=0x20; //Activating timers to generate the baud rate for serial comm
TH1=0xFD;
TL1=0x00;
SCON=0x50;
TR1=1;
IE=0x94; //Activating serial and external interrupts.
P2=0x00;
vote();
while(1);
}

NOTE:

You can implement matrix keypads in case if you need to use the above system for more than 8 candidates.
You can get the vote results whenever you needed.

SPI (Serial Peripheral Interface) tutorial in ARM7 Microcontroller

Frankpunter@gmail.com (Anonymous) — Sun, 28 Dec 2014 23:48:00 +0530

SPI ( Synchronous Peripheral Interface) is one of the important protocols used in Microcontrollers to establish serial communication between two devices. This protocol was widely used in many devices since the data transfer rate is pretty high than other protocols such as UART and I2C. This article will teach you to program SPI using ARM 7 Microcontroller.

The above design shows two controllers one of which is Master which transmits the data and the other one is the slave which receives the data and exhibit it its port1. The port 1 is provided with 8 LED's which indicate represents the received data from the master controller.

SPI PROTOCOL:

SPI is a synchronous, full duplex protocol which basically requires three communication lines to establish the connection between the devices. Hence it was also called as 3 wire interface protocol. A controller should act as a master and other should act like slaves. A master can have multiple slaves also both the master and slave can transmit/receive data. ARM 7 Microcontrollers possess two SPI controllers which controls SPI0 and SPI1.

PIN FUNCTIONS:

As i said above three communication line forms the backbone of this protocol, however a fourth one was also used to select the slaves by the master. The function of the Pins used in our controller is as follows.

MOSI - Master Output Slave Input pin serves as output pin for the Master and input for Slave.

MISO - Master Input Slave Output serves as input pin fro Master and output for the slave.

SCK - This pin generates the required clock for the communication to takes place. Master generates clock and feed the pulse to the slave device.

SSEL - This pin is used to select the slave device when multiple slave devices are used along with a single master. The SSEL is an active low pin, so to select a particular slave this pin should be pulled low.

REGISTERS USED IN SPI PROTOCOL:

In ARM7 controllers we use four registers to control the operation of the SPI they are as follows.

SPCR REGISTER:

SPI control register is an 8 bit register which is used to set the modes in which we SPI to operate. I have added a snippet of the bit functions in the register for better understanding.

SPSR REGISTER:

SPI status register is an 8 bit register which reveals the status of the SPI communication such as completion of transmission/ reception, mode fault etc.

SPDR REGISTER:

This register holds the data for transmission and reception. Data can be transmitted by writing in this register and data received can be read from this register.

SPCCR REGISTER:

This register controls the frequency of a master's SCK. The value of this register must be an even number and should be greater than or equal to 8. The SPI clock frequency is governed by the formula

SPI rate = PCLK (Processor Clock rate) / SPCCR value

STEPS TO PROGRAM SPI IN ARM CONTROLLERS:

MASTER MODE:

Select the functions of the pins MISO, MOSI, SCK using the PINSEL0 register.
Set the direction of the SSEL pin for selecting the slave connected to the controller.
Load the appropriate calculated value in the SPCCR register to generate the required clock frequency.
Select the master mode and set the clock phase, polarity using the SPCR register.
Select the slave by pulling the SSEL pin low.
Write the data in the SPDR register for transmission.
Check the status of the transmission by reading the SPIF bit in the SPSR register.

SLAVE MODE:

Select the slave mode using the SPCR register.
Wait until the SPIF flag in the status register is set.
Read the data from the SPDR register in the slave controller.

CODE:

This code was built using Keil uVision 4 compiler. The code was built in such a way to transmit data from a Master controller to the slave controller where the data is then sent to PORT 1.

#include<lpc21xx.h>
int main(void)
{
PINSEL0=(1<<8)|(1<<10)|(1<<12); //Selecting SPI pins
IODIR0=(1<<7);
IOSET0=(1<<7);
S0SPCCR=8; //SPI frequency
S0SPCR=0x38; //SPI master mode
IOCLR0=(1<<7);
while(1)
{
S0SPDR=0xff; //Data transmission
while(!(S0SPSR&(1<<7))); //Status check
S0SPDR=0x0f;
while(!(S0SPSR&(1<<7)));
}
}

NOTE:

Make changes in the above code as stated in the Programming steps of the Slave controller to obtain the code for the slave device.
You can use any pin to select the slave by pulling it low.
Multiple slaves can be connected to a single master by assigning each slave select that is SSEL pins from the master for the slaves.

Transmitting and receiving data using UART in PIC Microcontroller

Frankpunter@gmail.com (Anonymous) — Sat, 20 Dec 2014 20:18:00 +0530

UART or serial communication is one of the important protocol used by the Microcontrollers to transmit and receive data from the external devices. Almost every controller is equipped with this protocol to make transmission and reception easier just using two pins. This tutorial will teach you to initialize and send data by using UART in PIC microcontroller.

I assume that you are familiar with the concept of UART and proceed to explain the steps to initialize and use it in PIC controller. If you are familiar with the concept of UART kindly go through this link before proceeding.

REGISTERS USED IN UART:

TXSTA REGISTER: This register have the status and control bits of the Transmission in the controller.

RXSTA: This register holds the status and control bits of the Reception in the microcontroller.

SPBRG: This register holds the value which decides the baud rate of the serial communication. The formula governing the calculation varies based on the modes high speed and low speed.

LOW SPEED:

(Asynchronous) Baud Rate = FOSC/(64 (X + 1))

(Synchronous) Baud Rate = FOSC/(4 (X + 1))

HIGH SPEED:

Baud Rate = FOSC/(16 (X + 1))

Where X is the value of SPBRG register.

Since we are using standard 9600 bps, we are about to use 129 in the SPBRG register. According to the datasheet it results in giving 9600 bps 20MHZ crystal. You can find brief explanation of the bits in these registers in the datasheet of this controller.

PIC 16F877A DATSHEET DOWNLOAD

CODE:

This code was built using PIC C compiler. The code was built in a way to transmit the word "SRT" through UART to the hyperterminal and then print the received bytes in the LCD.

#include <usart.h>
#byte lcd=0x06
#byte TRIS_lcd=0x86
#bit en=0x07.1
#bit rs=0x07.0
#bit TRIS_en=0x87.1
#bit TRIS_rs=0x87.0
#byte TXSTA=0x98
#byte RCSTA=0x18
#byte SPBRG=0x99
#byte TXREG=0x19
#bit TXIF=0x0c.4
#byte RXREG=0x1A
#bit RXIF=0x0c.5
char c;
void display(char a,int b) //lcd subroutine
{
lcd=a;
rs=b;
en=1;
delay_ms(100);
en=0;
delay_ms(100);
}
void main()
{
TRIS_lcd=TRIS_rs=TRIS_en=0;
display(0x38,0);
display(0x01,0);
display(0x0f,0);
TXSTA=0x26; //initializing transmission
RCSTA=0x90; //Initializing reception
SPBRG=129; //Setting Baud rate
TXREG='S';
while(TXIF==0); //Waiting for transmission flag to set
TXREG='R';
while(TXIF==0);
TXREG='T';
while(TXIF==0);
while(TRUE)
{
while(RXIF==0); //Waiting for reception flag to set
c=RXREG;
display(c,1);
}
}

Christmas Tree lighting circuit

Frankpunter@gmail.com (Anonymous) — Tue, 16 Dec 2014 22:34:00 +0530

Christmas is just around the corner and its time to decorate our home with attractive lighting and other stuffs. The above given electronic design may help you to make a personalized Christmas tree lighting by your own. This circuit uses simple IC 555 and Dual flip flop IC to generate various frequency signals and use those signals to lit the LED's in a pattern. This will give a beautiful lighting effect. Also the cost of building this simple circuit is pretty low.

WORKING:

The 555 timer IC was wired as an astable multivibrator which produce square wave as output in its pin 3. The frequency of the output pulse depends on the Resistors and capacitor connected to the pin 7,6 and 2 of the timer IC. Also a pot can be used in the place of Resistor R1 if you wish to alter the operating frequency of the IC 555. The output frequency of the 555 was given by the equation

F= 1.44/ (R2 +2R1)C2

The dual flip flop IC 4013 forms the next stage of this design. The dual flip flops was wired in such a way to divide the frequency of the incoming signal from the astable multivibrator. The IC2:A divides the incoming signal by a factor of 2 and the output signal obtained from the pin 1 will be F/2 frequency of the original signal. On the other hand IC2:B divides the signal further by a factor of 2 and gives F/4 signal frequency in the output pin 13.

The final part of this circuit was the combination of LED's and transistors. The transistors was used to switch the LED's on and off. Only one transistor and LED combination was shown in the circuit for the simplicity of the design. Use individual Transistor and LED combination for each of the output signal that is F, F/2 and F/4 signal outputs.

Each transistor can drive about 20 LED's connected to it. You can increase the number of LED's by choosing the appropriate transistor to do the job. Thus the three different signal frequencies will produce a beautiful lighting effect.

NOTE:

Substituting R1 with (0-100k) POT will help you to obtain wide range of frequency outputs and it will increase the attractiveness of this lighting effect.
Choose different color LED's for each output signals.
Wound the LED's around your tree and your personalized lighting for X-mas tree is ready.

Vertical Image flip using CSS and HTML

Frankpunter@gmail.com (Anonymous) — Tue, 9 Dec 2014 22:13:00 +0530

Image flipping hover effects can be very useful where we need to display dual images about a specific theme or product in a single spot. This effect can be implemented very easily using simple CSS and HTML. You can view the demo of this vertical flip effect in the below link.

View Demo

CSS CODE:

.vertical_flip {
width:250px; height:250px; position:relative;
-webkit-transform-style: preserve-3d;
-webkit-transform-origin: 100% 125px;
-webkit-transition: all 0.7s ease;
transform-style: preserve-3d;
transform-origin: 100% 125px;
transition: all 0.7s ease;
}
.container:hover .vertical_flip {
-webkit-transform: rotateX(-180deg);
transform: rotateX(-180deg);
}
.front, .back {
width:250px;
height:250px;
position:absolute;
left:0;
-webkit-backface-visibility:hidden;
backface-visibility:hidden;
}
.back {
-webkit-transform: rotateX(180deg);
transform: rotateX(180deg);
}

The property "transform:rotateX(-180deg)" flips the front image to 180 degree revealing the image in the back when the container is hovered. "backface-visibility:hidden" is used to hide the alternate image so that a single image is displayed at an instant.

HTML CODE:

<div class="container">
<div class="vertical_flip">
<img class="front" src="Front Image URL">
<img class="back" src="Back Image URL"></img>
</div>
</div>

The HTML part of this code is pretty straightforward. All you have to do is to place the elements in "div" container with respective classes.

Universal Liquid level indicator with pump control

Frankpunter@gmail.com (Anonymous) — Fri, 5 Dec 2014 11:47:00 +0530

Liquid level indicator circuits are highly useful to monitor the level of liquids present in a tanks where access to the tanks are difficult. This circuit uses pressure sensor to sense the level of liquid in the tank which eliminates the drawbacks such as: corrosion of the sensing electrodes, ionic conduction property of liquid etc., which were used in the primitive liquid level indicator circuits. Also the alarm in this circuit offers the added advantage of alerting the user to turn OFF the liquid pump or valve.

WORKING OF CIRCUIT:

The tank is 6 to 7 feet deep and might contain oil, water, gasoline, or other liquids. A sense tube is connected to the pressure sensor port. It is attached to the bottom of the tank by either plumbing to a bottom of the tank drain line, or the sense tube is inserted to the bottom of the tank with an opening near the tank bottom. When the liquid fills the tank, the trapped air in the tube is compressed. The increase in pressure is proportional to the depth.

For water, every inch of water depth is an increase of 249.0892 Pascals of pressure. For a 7 foot deep tank, (84 inches), the resultant pressure increase in the sense tube would be 249.082 x 84 = 20,922.888 Pascals. The pressure sensor chosen is a Freescale MPXM2051G with a full scale of 7.25 PSI (50 kPa), and a full scale output of 40 mV. Since our example is 84 inches deep, the sensor output will be

40 mV * 20922.888 / 50,000 = 16.74 mV

In order to obtain the best resolution, a desired output for full is chosen to be between 4.0 and 4.5 volts. Thus, a gain of approximately

4.25 / .01674 = 253.883 is needed.

The pressure sensor is connected to Op-amp U2A and U2B via R6, and R7 respectively. U2A and U2B are used as differential input amplifier referenced to ground. This means that if the pressure sensor +/- outputs are equal, (when pressure is zero), then the output of U2B will be zero.

As the sensor pressure rises, the differential output increases. In our example, when the pressure reaches 20,922.88 Pa, or 20.923 KPa, then the output will be 16.74 mV. The GAIN of the differential amplifier, when R1/R2 = R4/R3 is GAIN = Vo/Vin = [1 + (R4/R3)] = [1 + (R1/R2)]. Applying this formula to the needed GAIN of about 250, The schematic values obtained were R1, R4 = 1 Meg, and R2, R3 = 3.9K ohms. Plugging those values into the GAIN formula yields,

[1 + (1Meg/3.9K)] = 257.41

Thus, at full scale, the sensor output for a depth of 84 inches = .01674 * 257.41 = 4.31 volts.

U2C and U2D serve as comparators which compare the output of U2B to an adjustable reference provided by R8 and R10. If more levels are desired, U2A and U2B can be in a MCP6022 dual RRIO op-amp and an additional MCP6024 quad RRIO op-amp can be used as a four level comparator. In the schematic, The tank can be filled to a desired level and the reference pot R8 adjusted so the LED, D1 just turns ON. The tank can then be filled to the full level and reference pot R10 adjusted so LED, D2 just turns ON. R12, Q1 and BZ1 form an audible alarm that can be added if desired to indicate the full level. Adding a switch to turn OFF the alarm may be desired.

If the dual - quad op-amp approach is used, the MCP6024 quad op-amp can be connected to the resistor ladder shown. All of the -inputs of the op-amps are connected to the output of U2B. The +inputs are connected to the 25%, 50%, 75%, and FULL nodes of the resistive ladder. R20 serves as an adjustment for the FULL tank level. Then each LED will represent a one fourth of FULL value. This only works for a vertical walled tank. If you use a cylinder on it's side, then the tank should be filled in fourths, a pot used to just turn ON the appropriate LED. In other words. Use a pot to adjust each individual LED level threshold.

One more thing could be added to automate the tank filling. If an R-S latch, (RESET-SET), was connected so that it was set when the tank was below one of the lower levels, say 50%, and then reset when it reached 100%, the latch output could drive a relay to turn ON and OFF a fill pump, or OPEN and CLOSE a solenoid fill valve. This would automate the tank filling procedure and eliminates the need of an alarm.

I included a circuit to simulate the sensor in order to test the circuit. It divides the 5 volt supply into a middle reference (Vsupp/2) and differential adjustment from 0 to 19 mV. I hope everyone finds this circuit useful for a universal liquid level indicator.

Finally, another thought is to take the output of U2B and perform an A/D conversion with a PIC microcontroller and then light a given LED whenever the A/D reading is above a defined level in the program. This way, you could have as many levels as desired. Another idea would be to do some simple integer math in the PIC and indicate the level on an LCD display as a percentage. The advantage would be higher resolution of the tanks fill level.

DESIGN AND TUTORIAL BY:

Ron Hoffman is the President of Hoffman Electronics Inc. He is a veteran in the field of Electronics and Embedded Systems. Also honored and listed in "Who's Who of American Inventors" 1996-1997;1998-1999 for patented inventions. Other than this he loves swimming, tennis, music and hiking. Read his articles in our site here.

Website: http://rjheinc.com/
Follow Him on LinkedIn: Ron Hoffman

DIY 30 Watt Stereo Amplifier Circuit

Frankpunter@gmail.com (Anonymous) — Wed, 3 Dec 2014 15:21:00 +0530

The Stereo Amplifiers are quite handy in places where we need to amplify the input signals to make it audible for all. Weather it was a party or a simple meeting, this thing will do a perfect job in there. This Stereo amplifier is easy to build and will provide amazing audio power and extremely low total harmonic distortion. It is much cleaner than anything I have seen on the market using standard audio IC's.

CIRCUIT DIAGRAM:

WORKING DESCRIPTION:

The pre-amp section uses two op-amps, U1A and U1B to provide treble and bass boost at low volumes and treble and bass controls for tailoring the sound to the user's preference. Selector switch S2A is a 2P4T, ( 2-pole, 4-throw (position)) rotary type to select from one of four line level inputs, (AUX, CD, TUNER, TAPE). They are coupled to U1A via C1, R1. Switches S3 and S4 are DPDT (double pole, double throw) slide switches that select for treble and bass boost.

As shown, they are in the OFF (no boost) position. R2 and C2 are shorted out by S4 canceling the bass boost. S1 is open which defeats the treble boost. R1 and R3 form a unity gain invertor/buffer and feed the signal to the treble/bass control network of U1B. If switch S3 is closed, then C3 is in parallel with R1 and boosts the treble gain at a break frequency of 2.34 KHz. If switch S4 is opened, then the feedback loop has an additional gain 16, and a low pass break frequency of 234 Hz.

The tone circuitry, Treble and Bass are enabled via U1B and the feedback network R4 - R9 and C4, C5. The Bass control has a break frequency around 190 Hz and a gain of around 16 db. The Treble control has a break frequency around 1500 Hz and a gain of 15 db. The output of U1B is connected by R11 to the balance control which has a grounded wiper. This decreases or increases the output of the Right and Left channels in an opposite manner to balance the signal level of a common input to both channels.

Resistor R11 connects to J5, the Pre-Amp Output jack and through R12 to J6, the Tape Output jack. Jack J7, is the Power-Amp input jack. A jumper cable must be connected from jacks J5 to J7 to pass the Pre-Amp signal to the Power-Amp. If desired, an effects processor, graphic equalizer or other audio processor can be inserted in the signal chain between jacks, J5 and J7, to further enhance the signal. Switch S5, when closed, combines the Right and Left channels for Mono operation. This is useful for a single channel mic input, or mono input, to enable sound to come out of both speakers, (Right and Left).

The Power-Amp circuit amplifies the line level signal at jack, J7, to power the 8-ohm Speaker. The signal is passed through C6, C7, which are wired to form a 5 uF non-polar capacitor, to the volume control, R14. The wiper of R14 passes the desired signal level through R15 to the positive input, (base of Q3), of the power op-amp stage.

Q3 and Q4 form the differential input pair of the power op-amp. D8, C8, R18, and R19 isolate the negative voltage rail and act as a current source to transistors, Q3, Q4. Transistor Q5, performs as a level shifter to drive the quasi-complimentary, cascode output pairs formed by transistors Q6, Q7 and transistors Q8, Q9 respectively. Diode D7 and R22 provide the correct bias voltage separation to provide about 10 to 20 mA of idle current through the output stage transistors and resistors R25, R26. This ensures that there is no cross-over distortion in the output signal, because the cascode output transistor pairs are actively conducting at the crossover transition.

Capacitor, C11 and resistors, R23, R24, form a bootstrap bias network that provides the negative bias to cascode transistor pair Q8, Q9, during the negative half cycle of the signal waveform. The Power-Amp stage gain is set by R21, R20 and C9. Except for frequencies lower than 8 Hz, C9 can be ignored in the GAIN equation.

GAIN = Vout/Vin = [1 + (R21/R20)] = 34 = 30.6 db.

Thus a .5 volt peak input voltage will yield a 17 volt output peak voltage which is ideal for the +/- 18 VDC supply. Transistors Q1, Q2 are connected as emitter follower voltage regulators to supply +/- 11 volts to the TL084 pre-amp IC.

LED D9 and current limiting resistor R29 indicate when the stereo is ON. The main power supply consists of transformer T1, 25.6 VAC, center-tapped, at 2 to 4 Amps. D1 - D4 form a full-wave bridge rectifier which is filtered by capacitors, C18, C19. Switch S6, Enables or Disables the speakers. Resistor R30 reduces the output before it is connected to the stereo headphone output jack (not shown).

NOTE:

Only the Right Channel Pre-Amp and Power Amp are shown, the Left channel is the same.
Use dual controls for Treble, Bass and Volume. Use DPDT slide switches for Treble and Bass Boost.
Use a 2P4T (2-pole, 4-throw, position) rotary switch to select sound signal source. Treble and Bass controls are linear taper.
The volume control is audio taper.

STEREO AMPLIFIER:

DESIGN AND TUTORIAL BY:

Website: http://rjheinc.com/
Follow Him on LinkedIn: Ron Hoffman

Simple FM bug circuit using Transistor

Frankpunter@gmail.com (Anonymous) — Sat, 29 Nov 2014 18:57:00 +0530

FM bugs are cool things and we might have seen many of them used in Movies. But we can actually make one fun FM bug using small number of components without spending much money. FM bug circuits should be miniature in size to keep it concealed. The above circuit shows a simple FM bug which was built around a single transistor.

WORKING OF CIRCUIT:

A simple Microphone was used to input the voice signals from the environment in which the bug is placed. The signal from the Microphone is then fed to the base of the transistor through a Capacitor C1 to impeded the different frequency present in the speech signal. The appropriate voltage at the base of the transistor is given by the combination of Resistors R1 and R3.

The variable Capacitor VC1 and inductor forms the parallel tank circuit which will vibrate at a resonant frequency. The VC1 is a variable capacitor which is used to generate the desired frequency. The resonant frequency signal generated by the tank circuit if governed by the equation

f= 1 / 2π√LC

The Capacitors C2 and C3 acts as a decoupling capacitors. Whereas the Capacitor C4 across the transistor serves to keep the tank circuit vibrating since frequency decay may occur due to heating losses. A thin strand of copper wire of length 30 inch can be used as an antenna in this above circuit. This circuit over a distance around 50 feet and only suitable for short ranges.

NOTE:

Use dead air frequencies for clear reception of the audio signals.
Changing the value of Resistor R2 will alter the sensitivity of the microphone.
This circuit was intended to hep building a fun bug circuit and cannot achieve much efficiency like the commercial ones.

Water level indicator Circuit

Frankpunter@gmail.com (Anonymous) — Tue, 25 Nov 2014 18:18:00 +0530

Wastage of water is really an issue in places where they use overhead tanks. Monitoring of water level is really a difficult task in those places and it could also lead to wastage of water and power. The above circuit shows a simple water level indicator system based on Tranistors and LED's. This circuit could give a simple and cost effective solution for this problem. This circuit was a simplified version of "Water level indicator" published in Instructables by Raikut.

WORKING OF CIRCUIT:

The circuit schematic comprises of totally two parts. Indicator section for indicating the water level present in the tank and Alarm section for alerting the people to turn off the pump once the tank is completely filled. The LED's are used for indicating the level whereas the transitors are used as a switching devices. A simple buzzer was used to sound provide the overflow warning. This circuit works based on the conductive property of the water.

The positive line of 6V is inserted into the tank, when there is no water in the tank all the three transistors will be in off state. When the water pump is turned on water starts filling the tank, when the water reaches the 1/4 level of the tank it comes in contact with the 1/4th level wire which is connected to the base of the transistor Q1. The water will provide a path for the current to flow from supply to the base of the terminal. This turns the tranistor Q1 in turn Red LED D1 which indicates that 1/4th level of tank is filled with water.

In the same way when the water reaches the 1/2th level it turns on yellow LED and when the tank is full it turns on the green LED. By this way the LED's help us to determine the level of water in the tank. Coming to the alarm section when the tank is full it turns the transistor Q4 which was wired as a switch to turn on the Buzzer which alerts the person to turn off the pump in order to avoid overflow of tank.

The switch given was used to turn off the alarm after the person is alerted. But do remember to turn the switch on before turning the Pump on or else the alarm won't work. For advanced version of this circuit refer to this article "Water Level Indicator Circuit with Alarm on Instructables".

NOTE:

You can increase various stages of water level by increasing the number of transitors and LED's in the circuit.
Try Using different colors of LED to avoid confusion or use a marker to write the appropriate water level near the LED's.

IDC Ribbon Cable Tester circuit

Frankpunter@gmail.com (Anonymous) — Fri, 21 Nov 2014 09:27:00 +0530

The ribbon cable tester is designed to check IDC (Insulation Displacement Connection) ribbon cables quickly for shorts to adjacent pins or opens from one end to the other. Originally, I designed this unit to test ribbon cables used on test equipment in the automotive industry. But it works for any ribbon cable. There are multiple types of sockets used with ribbon cables.

CIRCUIT DIAGRAM:

The most common are dual row headers (both male and female) and "D" type connectors (both male and female). If you build the tester and include two sets of 40-pin dual row headers (M&F) and "D" type (M&F) for the "O" port, and the "N" port, you should be able to test most types of ribbon cables. There are ".1" and "2" mm spacings too. Wire the four "O" headers and "D" 's in parallel and the "N" headers and "D" 's in parallel. This will allow the user to test male to female, male to male, female to female and female to male cables all on the same unit.

CIRCUIT OPERATION:

The heart of the Ribbon Cable Tester is the clock, U1A, (CD4093 schmitt NAND), R8, C1, they feed the clock pulses to the CP0 input of the U2 (CD4017 sequential decade counter). The outputs of U2 turn ON individually and sequentially with each rising edge clock pulse. After the fourth clock pulse, Q3 of U2, turns OFF, and Q4 turns ON. This resets U2 causing Q0 to turn ON, to continue the four step pattern. When U2, Q0 is (high, 1), the output of U3A is (low, 0), which turns transistor Q2 OFF and Q1 ON and makes output Q0 = (high, 1).

When U2 Q0 is (low, 0), the output of U3A is (high, 1), which turns transistor Q1 OFF and Q2 ON and makes output Q0 = (low, 0). So each time an output of the CD4017 goes (high, 1), so does the drive voltage of the corresponding output go (high, 1). U3A, plus transistors Q1 and Q2 form a power buffer to drive the LED matrix.

When output Q0 is (high, 1), current is able to flow through R6, and the LED to O1. When the Short/Continuity switch is in the continuity position, the O1 green LED will light if the path from O1 to N1 is correct. This applies for all of the corresponding On to Nn connections. When the Short/Continuity switch is in the short position, no LED's will light unless there is a short to an adjacent wire, such as wire O1 to O2, or O3 to O4 etc.

Using the first example, a short between O1 and O2 would cause the green O1 LED and the red O2 Led to light when output Q0 was ON, and would cause the green O2 LED and the red O1 LED to light when the Q1 output is ON. This would show the user that the short in the cable is between conductor 1 and conductor two. This could be from improper clamping of the IDC header on the cable, or faulty insulation between conductors, or a foreign object wedged into the ribbon cable between conductors. Whatever the reason, the Ribbon Cable Tester will find the problem.

The Normal/Test switch allows the user to test the unit to make sure everything is working properly. When the switch is in the Test position, all of the LED's light to show that the clock, counter, buffers and wiring is in good shape. In the Normal position, the unit is ready for testing ribbon cables for continuity and shorts. This is a really good device if you have a number of ribbon cables that need testing.

DESIGN AND TUTORIAL BY:

Website: http://rjheinc.com/
Follow Him on LinkedIn: Ron Hoffman