Electronics Projects

Device Controlling Using Android

2014-06-29T23:52:00.000-07:00

The purpose of this project is to demonstrate the basic principles of external device controlling using your android phone.

The basic principle in this project is that by interfacing an Android phone with a Arduino Board we can turn "off" or "on" some relays.

Components Required

Serial Port Bluetooth Module( TTL )
Arduino Microcontroller Board (ET-BASEAVR EASY328 ) Arduino Compatible Board
8 channel Output Relay Board

Connection Diagrams

Source Code For Arduino Board

For Arduino Microcontroller Board Source code

#define LED_PIN1 4
#define LED_PIN2 5
#define LED_PIN3 6
#define LED_PIN4 7

#define LED_PIN5 8
#define LED_PIN6 9
#define LED_PIN7 10
#define LED_PIN8 11

int firstSensor = 0;         // first analog sensor
int secondSensor = 0;    // second analog sensor
int thirdSensor = 0;        // digital sensor
int inByte = 0;           // incoming serial byte
boolean status_unlock;
boolean status_bluetooth;

long interval = 1000;           // interval at which to blink (milliseconds)
long previousMillis = 0;        // will store last time LED was update
int minite,sec;

void setup()
{
// start serial port at 9600 bps:
Serial.begin(9600);
//pinMode(2, INPUT);   // digital sensor is on digital pin 2
//establishContact();    // send a byte to establish contact until receiver responds

pinMode(LED_PIN1, OUTPUT);
pinMode(LED_PIN2, OUTPUT);
pinMode(LED_PIN3, OUTPUT);
pinMode(LED_PIN4, OUTPUT);

pinMode(LED_PIN5, OUTPUT);
pinMode(LED_PIN6, OUTPUT);
pinMode(LED_PIN7, OUTPUT);
pinMode(LED_PIN8, OUTPUT);

digitalWrite(LED_PIN1, LOW); // switch off LED
digitalWrite(LED_PIN2, LOW); // switch off LED
digitalWrite(LED_PIN3, LOW); // switch off LED
digitalWrite(LED_PIN4, LOW); // switch off LED

digitalWrite(LED_PIN5, LOW); // switch off LED
digitalWrite(LED_PIN6, LOW); // switch off LED
digitalWrite(LED_PIN7, LOW); // switch off LED
digitalWrite(LED_PIN8, LOW); // switch off LED

status_bluetooth = true;
status_unlock = false;
sec = 0;
}

void loop()
{
if (Serial.available() > 0) {

    inByte = Serial.read();                      // get incoming byte:

    if(inByte == 'A'){
      digitalWrite(LED_PIN1, HIGH);        // switch on LED
      Serial.print('A', BYTE);                    // send a char
      delay(800);
      digitalWrite(LED_PIN1, LOW);        // switch off LED
      status_unlock = false;
      inByte = 0;
    }

    if(inByte == 'a'){
      digitalWrite(LED_PIN2, HIGH);        // switch on LED
      Serial.print('a', BYTE);                    // send a char
      delay(800);
      digitalWrite(LED_PIN2, LOW);        // switch off LED

      status_unlock = true;
      sec = 0;
      inByte = 0;
    }

    if(inByte == 'B'){
      digitalWrite(LED_PIN3, HIGH);        // switch on LED
      Serial.print('B', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'b'){
      digitalWrite(LED_PIN3, LOW);        // switch off LED
      Serial.print('b', BYTE);                   // send a char
      inByte = 0;
    }

    if(inByte == 'C'){
      digitalWrite(LED_PIN4, HIGH);        // switch on LED
      Serial.print('C', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'c'){
      digitalWrite(LED_PIN4, LOW);        // switch off LED
      Serial.print('c', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'D'){
      digitalWrite(LED_PIN5, HIGH);        // switch on LED
      Serial.print('D', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'd'){
      digitalWrite(LED_PIN5, LOW);        // switch off LED
      Serial.print('d', BYTE);                   // send a char
      inByte = 0;
    }

    if(inByte == 'E'){
      digitalWrite(LED_PIN6, HIGH);        // switch on LED
      Serial.print('E', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'e'){
      digitalWrite(LED_PIN6, LOW);        // switch off LED
      Serial.print('e', BYTE);                   // send a char
      inByte = 0;
    }

    if(inByte == 'F'){
      digitalWrite(LED_PIN7, HIGH);        // switch on LED
      Serial.print('F', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'f'){
      digitalWrite(LED_PIN7, LOW);        // switch off LED
      Serial.print('f', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'G'){
      digitalWrite(LED_PIN8, HIGH);        // switch on LED
      Serial.print('G', BYTE);                    // send a char
      inByte = 0;
    }

    if(inByte == 'g'){
      digitalWrite(LED_PIN8, LOW);        // switch off LED
      Serial.print('g', BYTE);                   // send a char
      inByte = 0;
    }

    if(inByte == 'S'){

      Serial.print('S', BYTE);                  // send a char
      status_bluetooth = true;
      sec = 0;

    }
} // if(Serial

/*
unsigned long currentMillis = millis();

              if(currentMillis - previousMillis > interval) {
                previousMillis = currentMillis;         // save the last time you blinked the LED

                sec++;

                if(status_unlock==true){

                  if(sec== 11){

                      digitalWrite(LED_PIN1, HIGH);        // switch on LED

                      delay(800);
                      digitalWrite(LED_PIN1, LOW);        // switch off LED

                      status_unlock = false;
                      sec = 0;
                  }
                }
                else sec = 0;

              }

*/

} //Loop

void establishContact() {
while (Serial.available() <= 0) {
    Serial.print('.', BYTE);                   // send a capital A
    delay(500);
}
}

ANDROID BLUETOOTH CONTROLLED DEVICE

Android Bluetooth control application helps to control up to 8 external electrical or electronic devices. Use Android Bluetooth mobile device to remote control your device with Bluetooth Receiver hardware Device.

Main features of the program

It can control up to 8 devices.
These devices can be turned off /on by setting Timer to ON / OFF the device and show the time.(the timer can be set to 1 minute, 15 minutes, 30 minutes, 1 hour, 2 hours, 4 hours).
Use with Receiving device (Bluetooth Receiver Hardware Device see below).
Design for the Android version 4 and a screen resolution of 480 x 800 (WVGA).
Freeware with AD (free software)

Interfacing LED's with a micro controller(AT89c51)

2014-06-12T20:06:00.005-07:00

In this chapter we will learn how to interface LED using Micro controller. Here I have used the micro controller AT89c51.

The AT89C51 is a low-power, high-performance C MOS 8-bit microcomputer with 4K

bytes of Flash programmable and erasable read only memory (PEROM). The device is manufactured using Atmel’s high-density nonvolatile memory technology and is compatible with the industry-standard MCS-51 instruction set and pin-out. The on-chip Flash allows the program memory to be reprogrammed in-system or by a conventional nonvolatile memory programmer. By combining a versatile 8-bit CPU with Flash

on a monolithic chip, the Atmel AT89C51 is a powerful microcomputer which provides

a highly-flexible and cost-effective solution to many embedded control applications.

First let's see the architecture of AT89c51

As you can see, the controller has 40 pins, of them 32 pins are the parallel ports that are used for interfacing. These 32 pins are divided into 4 ports having 8pins for each. They are named as port 1, port 2, port 3, port 4.

Port 1:- p0.0,p0.1,p0.2,p0.3,p0.4,p0.5,p0.6,p0.7 ( pin no: 39-32)

Port 2- p1.0,p1.1,p1.2,p1.3,p1.4,p1.5,p1.6,p1.7 ( pin no: 1-8)

Port 3:- p2.0,p2.1,p2.2,p2.3,p2.4,p2.5,p2.6,p2.7 ( pin no: 28-21)

Port 4:- p3.0,p3.1,p3.2,p3.3,p3.4,p3.5,p3.6,p3.7 ( pin no: 10-17)

Pin 18 and 19 are for connecting crystal oscillator, pin 20 is ground and 40 is vcc.

You can use any/all of the 4 ports to interface LED's. In this experiment i had selected the Port 1:(p 0.0 - p0.7).

In this experiment we are going to interface 8 LED's.

Components required:-

1.      8 LEDs.
2.      Micro controller AT89c51.
3.      8 registers. (330 ohm)
4.      12MHz crystal oscillator.
5.      10 KΩ fixed register.
6.      10 μf (25v) capacitor.

Circuit diagram

Connections are made as per the circuit diagram. Here LED's are running of negative logic. That means normally every pin of port 1 have +5v as output. Here cathode of every LED is connected with Micro controller port pin and anode of all the LED's are connected to +5v supply. Thus both the legs of LED are supplied with +5v. So we required to give 0v at the output of micro controller in order to 'ON' the LED's.

We are sending the sequence of 0x055 and 0x0AA alternatively with some delay. Delay is in the range of few milliseconds.

Code :

#include<reg51.h>

void delay(int time) //This function produces a delay in msec.

{

int i,j;

for(i=0;i<time;i++)

for(j=0;j<1275;j++);

}

void main()

{

while(1)

{

P1=0x00; // this code turns ON the LED's

delay(100);

P1=0xff; // this code turns OFF the LED's

delay(100);

}

If port 2 is used then the code becomes :-

#include<reg51.h>

void delay(int time)

{

int i,j;

for(i=0;i<time;i++)

for(j=0;j<1275;j++);

}

void main()

{

while(1)

{

P2=0x00; // P1 changed to P2. If p3 is used then write P3 here.

delay(100);

P2=0xff;

delay(100);

}

If more than one port is used then the circuit diagram becomes:-

Here Port 1 and Port 3 are together used for interfacing 16 LED's.

Code (All 16 turned ON at a times)

#include<reg51.h>

void delay(int time)

{

int i,j;

for(i=0;i<time;i++)

for(j=0;j<1275;j++);

}

void main()

{

while(1)

{

P1=0x00; // this code turns ON the LED's in Port 1

P3=0x00; // this code turns ON the LED's in Port 3

delay(100);

P1=0xff; // this code turns OFF the LED's in Port 1

P3=0xff; // this code turns OFF the LED's in Port 3

delay(100);

}

Code (Only 8 LED's turned ON at a times)

#include<reg51.h>

void delay(int time)

{

int i,j;

for(i=0;i<time;i++)

for(j=0;j<1275;j++);

}

void main()

{

while(1)

{

P1=0x00; // this code turns ON the LED's in Port 1

P3=0xff; // this code turns OFF the LED's in Port 3

delay(100);

P1=0xff; // this code turns OFF the LED's in Port 1

P3=0x00; // this code turns ON the LED's in Port 3

delay(100);

}

tags: interfacing LED with PIC, embedded projects for beginners, embedded tutorials for beginners, LED interfacing circuits, LED tutorials, LED blinking circuits, LED blinking tutorials, AT89c51 beginners projects, AT89c51 tutorials, micro controller tutorial projects, micro controller circuits for beginners

Parallel Ports Basics

2014-06-12T20:06:00.002-07:00

In this chapter we will discuss about the parallel ports.

Parallel ports are a set of pins used to interface external devices. The number of such ports are different for different micro controllers. Simply it can be defined as, we know that a micro controller is a programmed device which will perform as per the program. So in order to perform some actions the controller should be connected to some device/ circuit. As an example, in circuit we want to blink an LED for 5 seconds whens a key is pressed.Then we have to connect a switch and a LED to the controller. So we use the parallel ports to connect these components. The below picture shows the basic structure to connect an LED and switch to the controller.

We can choose any two pins( depends on the type of controller) and assign one pin(say pin-1) for the switch and the other(pin-2) for connecting the LED. And the a program is written in a manner that when the switch is pressed blink the LED for next five seconds.

Program logic: when the switch is closed the pin is actually connected to ground. That means a 'zero' is given as input. Then as per the program when a 'zero' is detected in pin-1, a loop/timer starts counting till 5 seconds, and an output is given to the pin-2 till the loop/timer ends. Out put means a 'one' is given to the pin-2 which is +5 volts causes the LED to blink.

Uses of parallel ports:

Usually micro controllers are not used in simple circuits as stated above. They are always used in much bigger circuits and devices that have lots of functions depending on the situations. Situations simply mean the conditions that are given by the user.

As example suppose we want a device, when temperature in a room is becomes higher than a particular value, which will turn on the air conditioner and if the temperature falls beyond a value then turn offs the air conditioner. Then we have got two conditions that are, two temperatures. Using a digital thermometer we continuously check the temperature and the readings are given to the micro controller through any one pin of the micro controllers parallel port. Then we wright the program to detect the condition ( both the values of temperature) and also what to do for that conditions.

Or in some other devices we have to detect several conditions and have to perform so many functions. Also these ports are used to interface other chips and external memory. That will be discussed in the following chapters.

What is a microcontroller

2014-06-12T20:05:00.002-07:00

In the first chapter we will discuss about - what is a micro controller?

So first let me tell you what is the difference between an IC and a micro controller or what is the difference between normal IC controlled circuit and a micro controller controlled circuit.

A normal IC is or integrated circuit , sometimes called a chip or microchip, is a semiconductor wafer on which thousands or millions of tiny resistors, capacitors, and transistors are fabricated. An IC can function as an amplifier, oscillator, timer, counter, computer memory, or microprocessor. A particular IC is categorized as either linear (analog) or digital, depending on its intended application.
Such an IC is pre programmed or the purpose of its application is defined by the manufactures and those IC's can be used only for that purpose.

Now come to micro controller

A micro controller is a small, low-cost computer-on-a-chip which usually

includes:–

An 8 or 16 bit microprocessor (CPU)
A small amount of RAM
Programmable ROM and/or flash memory
Parallel and/or serial I/O
Timers and signal generators
Analog to Digital (A/D) and/or Digital to Analog (D/A) conversion.

In a micro controller, the device is user programmable. That is the user can write programs as per his needs and can be loaded into the micro controller. So a single micro controller can be used for various purposes by changing the program written into it.
It is also called embedded controllers, because the micro controller and support circuits are often built into, or embedded in, the devices they control.Embedded products are designed to allow the user to provide input and receive results.

Basic structure of a micro controller

Block diagram explanation:

Crystal oscillator:- It has the same function as that of a human heart. It generates the clock pulses through which the entire functions of the micro controller are carried out.

ADC/DAC:- Since the micro controller is a digital device, the ADC/DAC port/pin is used for interfacing the external analog devices

Timers/Counters:- The timer TMR0 has a wide range of applications in practice. Very few programs don't use it in some way. It is very convenient and easy to use for writing programs or subroutines for generating pulses of arbitrary duration, time measurement or counting external pulses (events) with almost no limitations.

Parallel I/O ports:- have a wide range of alternative functions:

• UART Universal asynchronous receiver/transmitter

• SSI Synchronous serial interface

• I²C Inter-integrated circuit

• Timer Periodic interrupts, input capture, and output compare

• PWM Pulse width modulation

• ADC Analog to digital converter, measure analog signals

• Analog Comparator Compare two analog signals

• QEI Quadrature encoder interface

• USB Universal serial bus

• Ethernet High-speed network

• CAN Controller area network

Detailed explanation of the block diagram will be published in the following posts, thank you.

tags: embedded for beginners, embedded tutorials, micro controller tutorials, micro controller basics, micro controller tutorials, micro controller basics

PIC Serial Communication Tutorial (UART)

2013-11-06T01:50:00.002-08:00

First, a quick history of RS232. What is RS232? It's just a name for a standard that has propagated from generation to generation of computers. The first computers had serial ports that used RS232, and even current computers have serial ports (or at least USB ports that act like RS232 ports). Back in the day, serial information needed to be passed from devices like printers, joysticks, scanners, etc to the computer. The simplest way to do this was to pass a series of 1s and 0s to the computer. Both the computer and the device agreed on a speed of information - 'bits per second'. A computer would pass image data to a printer at 9600 bits per second and the printer would listen for this stream of 1s and 0s expecting a new bit every 1/9600 = 104us (104 micro-seconds, 0.000104 seconds). As long as the computer output bits at the pre-determined speed, the printer could listen.
Zoom forward to today. Electronics have changed a bit. Before they were relatively high power, high voltage devices. The standard that is 'RS232' dictates that a bit ranges from -12V to +12V. Modern electronics do not operate at such high positive and negative voltages. In fact, our PIC runs 0V to 5V. So how do we get our 5V micro to talk the RS232 +/-12V voltages? This problem has been solved by the IC manufacturers of the world. They have made an IC that is generically known as the MAX232 (very close to RS232, no?).
The MAX232 is an IC originally designed by a company called Maxim IC that converts the +/-12V signals of RS232 down to the 0/5V signals that our PIC can understand. It also boosts the voltage of our PIC to the needed +/-12V of the RS232 protocol so that a computer can understand our PIC and vice versa. To get our PIC IC sending serial characters to a computer, we have to send these serial signals through a MAX232 circuit so that the computer receives +/-12V RS232 signals. Don't worry if you're working with a chip labeled 'ICL232' or 'ST232' - these are just generics of the MAX232. Everyone says 'MAX232'. The ICs all function the same and nearly all have the same pinout.

Discussion Group

Circuit

Read full article

FM Radio jammer

2013-11-06T01:36:00.000-08:00

FM Radio jammer

Description.
Circuit shown here can be used to jam FM radios in its vicinity. The circuit is nothing but a classic single transistor oscillator operating in the VHF region. Working principle of the circuit is very simple and straight forward. Powerful VHF oscillations from the circuit will interfere with the FM signals to nullify it. Jammer circuits like this are illegal in many countries and you must assemble this circuit on your own responsibility. This circuit is intended only for fun and i request you not to misuse it.
Circuit diagram.

Notes.

For L1 make 6 turns of 16AWG enamelled copper wire on a 9mm plastic former.
The circuit can be powered using a 9V PP3 battery.
For extended range, use an antenna.
A 30cm long wire connected anywhere on the coil will do for the antenna.
For better performance, assemble the circuit on a good PCB.

Reference : www.circuitstoday.com, www.wikipedia.com, www.microcontrollerprojects00.blogspot.in

Heart rate monitor using 8051

2013-09-01T00:05:00.004-07:00

In this article we are listing all the projects and circuits we have developed using the 8051 micro controller. We have tested all of these projects in our lab and verified the working . All these projects are made to solve a real world requirement or problem. Engineering students & other diploma students will find these projects useful for their mini project and main project requirements.
All the 8051 projects listed below are made using the 8051 compliant microcontroller from Atmel – AT89S51. We have given the correct circuit diagram, working and software code (in assembly language) for each and every project. You can use all of them freely for your project & learning requirements. In case you are using a controller other than AT89S51 – please be sure to check the hardware of your controller and compare it with that of AT89S51. This is necessary because we have developed all the software in assembly language. If you are not that good at assembly language, you can convert the software into C language & use it with any compliant 8051 controller.

Image Source
1. Ultrasonic Range Finder using 8051 – This project as the name says, is an application to measure distance of an object. It uses an ultrasonic transducer module HC-SR04 to measure the distance and the controller AT89S51 to make the necessary processing. This project can be used to make applications like Automotive parking sensor, Obstacle warning systems, Terrain monitoring robots etc. This ultrasonic range finder can measure distances upto 2.5 meters with an accuracy of 1 cm.
2. Digital Tachometer using 8051 – This project is a digital tachometer which can be used to measure the revolutions per second of any object like a rotating wheel or a disc or a shaft. This application built using 8051 micro controller can measure upto 255 revolutions/second with an accuracy of 1 rev/sec. This application has 3 important sections – 1) is the optical pickup designed to pick the revolutions of the object using a photo transistor and LED. 2) is the processing stage designed using 8051 and the associated software 3) is the display section using 7 segment displays.
3. Water Level Controller using 8051 – This is one of the most popular project we have published using 8051 controller. This water level controller monitors the level of the over head tank and automatically switches on the water pump when ever the level goes below a preset limit. The level of the over head tank is indicated using 5 leds and the pump is switched of when the over head tank is filled. We have given an illustrated circuit diagram with working explained in detail. You will also find the software codes written in assemble language.
4. Voltmeter using 8051 - We all must have used a multimeter from our young days. Have you ever bothered to create one ? So here is one such an interesting project. A Voltmeter using 8051 micro controller. Even though its quiet simple and an easy to make one, you shall find it really interesting. This can be used as an application at the mini project level for engineering and diploma students. This digital voltmeter can measure 0 to 5 volts and has a sensitivity of 200mV which is a bit low but this project is meant for demonstrating how an ADC and seven segment display can be interfaced to 8051 to obtain a digital readout of the input voltage. ADC0804 is the ADC and AT89S51 is the controller used in this project.
5. Thermometer using 8051 - This is an interesting project designed to measure temperature using 8051. Its a simple 0-100°C digital thermometer with 1°C resolution using 8051. The circuit is based on LM35 analog temperature sensor, ADC0804 and AT89S51 microcontroller. LM35 is an analogue temperature sensor IC which can measure a temperature range of -55 to 150°C. Its output voltage varies 10mV per °C change in temperature.
Knowledge Resources:- The articles below given are basics on how to work with 8051 micro controller. You can refer them if you come across a road block anywhere!
1. Interfacing 7 segment display to 8051 – A good tutorial on interfacing 7 segment display to 8051 micro controller.
2. Interfacing LCD display to 8051 – Explains how to interface a 16×2 LCD display with 8051 micro controller.
3. Interfacing DC motor to 8051 – Explains how to interface a DC motor with 8051 micro controller.
4. Interfacing push button switch to 8051 – Interfacing LED & Push button switch to 8051 micro controller.
5. Interfacing ADC to 8051 – This articles gives you a good detail on how to interface ADC to 8051 micro controller. ADC 0804 is used to explain the interfacing procedure with an example software routine.

Alcohol Breathalyzer circuit using 8051 microcontroller (AT89S51).

2013-09-01T00:02:00.000-07:00

This article is about a breathalyzer circuit using 8051 microcontroller which outputs the blood alcohol content (BAC) from the breath. The BAC is displayed in percentage on a 3 digit seven segment display. The microcontroller used if AT89S51 which belongs to the 8051 family and the alcohol sensor is MQ135 gas sensor from Futurelec.

MQ135 gas sensor.

MQ135 is a stable and sensitive gas sensor which can detect ammonia, carbon dioxide, alcohol, smoke, nitrogen dioxide etc. The sensor consists of a tin dioxide sensitive layer inside aluminium oxide micro tubes, measuring electrode and a heating element inside a tubular aluminium casing. The front end of the sensor is covered using a stainless steel net and the rear side holds the connection terminals.

The ethyl alcohol present in the breath is oxidized into acetic acid while passing over the heating element. This ethyl alcohol falls on the tin dioxide sensing layer and as a result its resistance decreases. This resistance variation is converted into a suitable voltage variation using an external load resistor. The typical connection arrangement of an MQ135 alcohol sensor is shown below.

MQ135 alcohol sensor

MQ135 has different resistance values at different temperature and different concentration of gases. The manufacturer recommends to calibrate the sensor at 100ppm of ammonia or 50ppm of alcohol. The recommended value of the load resistor is between 10K to 47K.

Circuit diagram.

Breathalyzer using 8051

The voltage output of the alcohol sensor is converted into a digital format using the ADC0804 (IC1). The Vref/2 pin of the ADC is held at 1.28V using the voltage divider network made of R14 and R15. Vref/2 =1.28V means the step size of the ADC will be 10mV and the output of the ADC will increment by one bit for every 10mV increment in the analog input. Refer the datasheet of ADC0804 for a better grasp. Digital out of the ADC (D0 to D7) is interfaced to Port1 of the microcontroller. Control signals CS, RD, WR, INTR are obtained from the microcontrollers P3.7, P3.6, P3.5, P3.4 pins respectively. R9 and C1 are associated with the clock circuitry of the ADC0804.

Capacitor C3 connected between Vin+ and Vin- of the ADC0804 filters of noise (if any) in the sensor output. If C3 is not used the digital output of the ADC will not be stable. This filter capacitor will surely induce some lag in the ADC response but it is not very relevant in this entry level application. The microcontroller performs required manipulations on the ADC digital output in order to convert it into BAC % and displays it on the three digit seven segment display. Port0 of the microcontroller is interfaced to the multiplexed three digit seven segment display. The drive signals for the threes digits are obtained from the microcontroller’s P3.0, P3.1, P3.2 pins respectively.

Program.

ORG 00H
MOV P1,#11111111B
MOV P0,#00000000B
MOV P3,#00000000B
MOV DPTR,#LUT
MAIN: MOV R4,#250D
      CLR P3.7
      SETB P3.6
      CLR P3.5
      SETB P3.5
WAIT: JB P3.4,WAIT
      CLR P3.7
      CLR P3.6
      MOV A,P1
      MOV R5,A
      SUBB A,#86
      JC NEXT
      SETB P3.3
      CLR PSW.7
NEXT: MOV A,R5
      SUBB A,#115D
      JNC LABEL
      MOV A,#00000000B
      CLR PSW.7
LABEL: MOV B,#5D
       MUL AB
       MOV B,#8D
       DIV AB
       MOV B,#10D
       DIV AB
       MOV R6,A
       MOV R7,B
DLOOP:SETB P3.0
      MOV P0,#01000000B
      ACALL DELAY
      CLR P3.0
      SETB P3.1
      MOV A,R6
      ACALL DISPLAY
      MOV P0,A
      ACALL DELAY
      CLR P3.1
      SETB P3.2
      MOV A,R7
      ACALL DISPLAY
      MOV P0,A
      ACALL DELAY
      CLR P3.2
      DJNZ R4,DLOOP
      SJMP MAIN
DELAY: MOV R3,#255D
LABEL1: DJNZ R3,LABEL1
        RET
DISPLAY: MOVC A,@A+DPTR
         CPL A
         RET
LUT: DB 3FH
     DB 06H
     DB 5BH
     DB 4FH
     DB 66H
     DB 6DH
     DB 7DH
     DB 07H
     DB 7FH
     DB 6FH
END

Notes.

The MQ135 gas sensor requires around 5 minutes of preheat before the first use.
The MQ135 takes few minutes to retrace back to its normal condition after a positive test (alcohol present in the breath).
If there is no alcohol in the breath the sensor output will swing back to its normal condition very fast.
Read these articles Interfacing seven segment display to 8051 microcontroller , Interfacing ADC to 8051 microcontroller before attempting this project.
This breathalyzer circuit is just an entry level one and is not suitable for high end applications such as law enforcement or laboratory application.
The logic for converting the digital output of ADC into BAC percentage was obtained using approximation techniques.

Online Work

2013-08-01T08:03:00.001-07:00

Are you interested in making money online ???

Thanks to the Internet there are now hundreds of opportunities to work online from home using your ordinary computer. Our company is doing online job consultancy for everyone and we wants that you can make money online working from home using these methods and our guidance. These opportunities are open to all including working, housewives, teens*, students etc.

A computer and an internet connection is the basic requirement.

If you want…

If you want to do PART-TIME or FULL TIME JOB from Home

If you want a Very Good Monthly Income Easily at home

If you are tired to work hard to earn your daily needs

If you don’t want to go any office and want to work from home

If you are tired to obey Boss rules

If you tired with your daily routine life and want a financial change.

If you can spare only 1 to 2-3 hours daily

If you really want to do Easy Online Computer Based Jobs

Can Anyone Make Money Online Working From Home?

Of course. Many thousands of people do. You might have friends or family members who make a living with a home-based Internet business already.

Who can start this business?

Now the question comes that Who can start this business ?

You will only need a internet connection on your computer.

No issue if you are using internet very first time, or you are a good experienced.

You can do it with your own computer or anywhere like cyber-cafe.

You will have to give some minutes to few hours only to do this all

No skill on computer is required whether you are a housewife, a student, retired person,already working in a company, own business etc. anyone can start working.

If you want to start NOW… then you are at right place…

STM32F4 Discovery Tutorial 1 Using NETMF - Setting Up the Environment

2013-06-16T07:55:00.000-07:00

STM32F4 Discovery

I received my STM32F4 Discovery board few days ago. During these days I am searching for a good compiler for the STM32 which is free or provide a better code sized free version. I am already working in .Net environment using C#, and I it is pretty good. In Google search I saw STM32F4 programming using .Net, the below link.

http://netmf4stm32.codeplex.com/

We are using a .net port for STM32F4, it is .Net micro framework.
I am using Visual Studio Ultimate 2010 (Compatibility of others is not known).

Download Visual Studio

I hope you have an STM32F4 Discovery Board.

Necessary Tools

1. STM32 ST-LINK Utility Get It ->

2. USB Micro and USB Mini cable.

3. .NET MicroFramework SDK Get It ->

4. Download these files (Evaluation purpose only driver)

i. If you are not a member, join

Install all the softwares.

Steps to follow: Click here

Smart Home : The Project

2013-06-16T07:51:00.000-07:00

ABSTRACT

Smart home technology has proved to contribute to increased independence and safety. Smart Home Technology is a collective term for information and communication technology in homes, where the components are communicating through a local network. The technology may be used for monitoring, alarming and executing actions, according to the programmed criteria. These project includes a high level security system informs the authorized person and to the police station by a dedicated software using internet. The heart of the project is a Web Server running on an ARM Cortex M4 microcontroller. There are various sensors, devices connected to this device for security system, control and monitoring. Dedicated softwares are there for user (.Net and Android) and police station (.Net). The user software can control the devices in home, view various sensor readings, status of security system, change configuration etc. The application used in the police station use maps of local area to provide the intruder alert. The software used in police station will be communicating with this home server and if an intruder is detected, it will be shown in the software as a location in map and a notification message which makes their duty easily. Same time the house owner will be informed by the user software. The software communicates to the Smart Home Device using UDP protocol. The user software is compatible for future developments like camera interfaces.

courtesy : http://microcontrollerprojects00.blogspot.in
read full

Multidoor Cordless Alarm

2013-06-04T22:09:00.003-07:00

Thwart the attempt of burglary by detecting intrusion with this alarm circuit. Each door is protected by a separate circuit built around an independent 555 timer IC in conjunction with reed switch magnet. All the three units are powered from a single power source. The buzzer can be plugged into the earth line of a socket in any room of the same building having proper earth line connection. There is no need of laying external wires up to the buzzer unit from different rooms.

Fig. 1: Cordless multidoor alarm

For door-1 alarm unit, connect reed switch S1 near the magnet of gate 1. Wire IC1 as a frequency oscillator and set door-1 alarm unit to the desired frequency, say, between 1 Hz and 3 Hz, using VR1. For door-2 alarm unit, connect reed switch S2 near the magnet of gate 2. Wire IC2 also as a frequency oscillator and set door-2 alarm frequency between 5 and 7 Hz using VR2. For door-3 alarm unit, connect reed switch S3 near the magnet of gate 3. Wire IC3 also as a frequency oscillator and set door-3 alarm frequency between 10 and 12 Hz using VR3.

The power supply required to operate the alarm circuits consists of a bridge rectifier and filter capacitor C10. In normal condition, i.e., when all the doors are closed, reset pin 4 of IC1 through IC3 remains low. As a result, these do not oscillate and piezobuzzer PZ1 remains silent.

When door 1 is opened, the magnet moves away from reed switch S1. IC1 generates 1-3Hz signals and the piezobuzzer beeps to indicate that door 1 has been opened. When door 2 is opened, IC2 generates 5-7Hz signals and the piezobuzzer beeps to indicate that door 2 has been opened. Similarly, when door 3 is opened, the piezobuzzer beeps at the rate of 10 to 12 Hz, indicating that door 3 has been opened.

Fig. 2: Circuit of remote buzzer unit

Thus sitting in a room where the buzzer unit is fitted, you can easily know (through the typical sound of the buzzer) which room has someone gained entry into.

Assemble the circuit on a general-purpose PCB and connect the output to any socket (SOC1) inside the building as shown in Fig. 1. Mains line wire is not connected to SOC1. Live and neutral wires are connected to the primary of the step-down transformer, which is a part of the power supply. All the three units connected are powered from a single rectified power supply. Connect the reed switch near the particular gate magnet through an external wire.

Plug-in the piezobuzzer into the earth and neutral lines of socket (SOC2) fitted in the desired room of the same building. There is no need of laying external wires up to the buzzer unit. This project will work off the power line within the building.

EFY lab. In the buzzer unit, a zener diode (ZD1) is used as the voltage between earth and neutral is around 9V instead of 0V. If you find the ideal voltage difference of zero volt between earth and neutral lines, the circuit will work even without ZD1 in the circuit

Convert WASTE BASKET into a spy robot

2013-05-23T10:02:00.001-07:00

Circuit Theory

Circuit

Description

For description please click here

tags: spy robots, electronics projects, inventory projects

High power LED torch

2012-10-09T20:53:00.005-07:00

This is a simple and very old circuit idea, even though i am publishing here for those who haven't seen this before and for beginners in electronics circuits. It' s nothing but an ordinary LED of 1.5 V circuit realized using salvaged components!!

tags: basic electronics, simple electronics circuits, high power LED torch , bright light circuits, LED torch circuit, how to make an LED torch

PIC Serial Communication Tutorial (UART)

2012-10-09T08:29:00.003-07:00

This is a study of the PIC serial communication. First we should study about RS232. It's just a name for a standard that has propagated from generation to generation of computers. The first computers had serial ports that used RS232, and even current computers have serial ports (or at least USB ports that act like RS232 ports). Back in the day, serial information needed to be passed from devices like printers, joysticks, scanners, etc to the computer. The simplest way to do this was to pass a series of 1s and 0s to the computer. Both the computer and the device agreed on a speed of information - 'bits per second'. A computer would pass image data to a printer at 9600 bits per second and the printer would listen for this stream of 1s and 0s expecting a new bit every 1/9600 = 104us (104 micro-seconds, 0.000104 seconds). As long as the computer output bits at the pre-determined speed, the printer could listen.
Zoom forward to today. Electronics have changed a bit. Before they were relatively high power, high voltage devices. The standard that is 'RS232' dictates that a bit ranges from -12V to +12V. Modern electronics do not operate at such high positive and negative voltages. In fact, our PIC runs 0V to 5V. So how do we get our 5V micro to talk the RS232 +/-12V voltages? This problem has been solved by the IC manufacturers of the world. They have made an IC that is generically known as the MAX232 (very close to RS232, no?).
The MAX232 is an IC originally designed by a company called Maxim IC that converts the +/-12V signals of RS232 down to the 0/5V signals that our PIC can understand. It also boosts the voltage of our PIC to the needed +/-12V of the RS232 protocol so that a computer can understand our PIC and vice versa. To get our PIC IC sending serial characters to a computer, we have to send these serial signals through a MAX232 circuit so that the computer receives +/-12V RS232 signals. Don't worry if you're working with a chip labeled 'ICL232' or 'ST232' - these are just generics of the MAX232. Everyone says 'MAX232'. The ICs all function the same and nearly all have the same pinout.

Circuit

UART Library

The UART hardware module is available with a number of PIC compliant MCUs. The mikroC PRO for PIC UART Library provides comfortable work with the Asynchronous (full duplex) mode.

You can easily communicate with other devices via RS-232 protocol (for example with PC, see the figure at the end of the topic – RS-232 HW connection). You need a PIC MCU with hardware integrated UART, for example 16F887. Then, simply use the functions listed below.

Important :

UART library routines require you to specify the module you want to use. To select the desired UART module, simply change the letter x in the routine prototype for a number from 1 to 2.
Switching between the UART modules in the UART library is done by the UART_Set_Active function (UART modules have to be previously initialized).
Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

Library Routines

Generic Routines

UARTx_Init

Prototype	void UARTx_Init(const unsigned long baud_rate);
Returns	Nothing.
Description	Initializes desired hardware UART module with the desired baud rate. Refer to the device data sheet for baud rates allowed for specific Fosc. If you specify the unsupported baud rate, compiler will report an error.
Requires	You need PIC MCU with hardware UART. UARTx_Init needs to be called before using other functions from UART Library. Parameters : baud_rate: requested baud rate Refer to the device data sheet for baud rates allowed for specific Fosc. Note : Calculation of the UART baud rate value is carried out by the compiler, as it would produce a relatively large code if performed on the library level. Therefore, compiler needs to know the value of the parameter in the compile time. That is why this parameter needs to be a constant, and not a variable.
Example	// Initialize hardware UART1 and establish communication at 9600 bps UART1_Init(9600);

UARTx_Data_Ready

Prototype	char UARTx_Data_Ready();
Returns	1 if data is ready for reading 0 if there is no data in the receive register
Description	Use the function to test if data in receive buffer is ready for reading.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	// If data is ready, read it: if (UART1_Data_Ready() == 1) { receive = UART1_Read(); }

UARTx_Tx_Idle

Prototype	char UARTx_Tx_Idle();
Returns	1 if the data has been transmitted 0 otherwise
Description	Use the function to test if the transmit shift register is empty or not.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	// If the previous data has been shifted out, send next data: if (UART1_Tx_Idle() == 1) { UART1_Write(_data); }

UARTx_Read

Prototype	char UARTx_Read();
Returns	Returns the received byte.
Description	Function receives a byte via UART. Use the function UARTx_Data_Ready to test if data is ready first.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	// If data is ready, read it: if (UART1_Data_Ready() == 1) { receive = UART1_Read(); }

UARTx_Read_Text

Prototype	void UARTx_Read_Text(char Output, char* Delimiter, char* Attempts);
Returns	Nothing.
Description	Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter output; delimiter sequence is stored in the parameter delimiter. This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found). Parameters : Output: received text Delimiter: sequence of characters that identifies the end of a received string Attempts: defines number of received characters in which Delimiter sequence is expected. If Attempts is set to 255, this routine will continuously try to detect the Delimiter sequence.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	Read text until the sequence “OK” is received, and send back what’s been received: UART1_Init(4800); // initialize UART1 module Delay_ms(100); while (1) { if (UART1_Data_Ready() == 1) { // if data is received UART1_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART1_Write_Text(output); // sends back text } }

UARTx_Write

Prototype	void UARTx_Write(char data_);
Returns	Nothing.
Description	The function transmits a byte via the UART module. Parameters : _data: data to be sent
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	unsigned char _data = 0x1E; ... UART1_Write(_data);

UARTx_Write_Text

Prototype	void UARTx_Write_Text(char * UART_text);
Returns	Nothing.
Description	Sends text via UART. Text should be zero terminated. Parameters : UART_text: text to be sent
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	Read text until the sequence “OK” is received, and send back what’s been received: UART1_Init(4800); // initialize UART1 module Delay_ms(100); while (1) { if (UART1_Data_Ready() == 1) { // if data is received UART1_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART1_Write_Text(output); // sends back text } }

UART_Set_Active

Prototype	void UART_Set_Active(char (read_ptr)(), void* (write_ptr)(unsigned char* data_), char (ready_ptr)(), char* (*tx_idle_ptr)())
Returns	Nothing.
Description	Sets active UART module which will be used by the UART library routines. Parameters : read_ptr: UARTx_Read handler write_ptr: UARTx_Write handler ready_ptr: UARTx_Data_Ready handler tx_idle_ptr: UARTx_Tx_Idle handler
Requires	Routine is available only for MCUs with two UART modules. Used UART module must be initialized before using this routine. See UARTx_Init routine
Example	UART1_Init(9600); // initialize UART1 module UART2_Init(9600); // initialize UART2 module RS485Master_Init(); // initialize MCU as Master UART_Set_Active(&UART1_Read, &UART1_Write, &UART1_Data_Ready, &UART1_Tx_Idle); // set UART1 active RS485Master_Send(dat,1,160); // send message through UART1 UART_Set_Active(&UART2_Read, &UART2_Write, &UART2_Data_Ready, &UART2_Tx_Idle); // set UART2 active RS485Master_Send(dat,1,160); // send through UART2

UART_Data_Ready

Prototype	char UART_Data_Ready();
Returns	1 if data is ready for reading 0 if there is no data in the receive register
Description	Use the function to test if data in receive buffer is ready for reading. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	// If data is ready, read it: if (UART_Data_Ready() == 1) { receive = UART_Read(); }

UART_Tx_Idle

Prototype	char UART_Tx_Idle();
Returns	1 if the data has been transmitted 0 otherwise
Description	Use the function to test if the transmit shift register is empty or not. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	// If the previous data has been shifted out, send next data: if (UART_Tx_Idle() == 1) { UART_Write(_data); }

UART_Read

Prototype	char UART_Read();
Returns	Returns the received byte.
Description	Function receives a byte via UART. Use the function UART_Data_Ready to test if data is ready first. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	// If data is ready, read it: if (UART_Data_Ready() == 1) { receive = UART_Read(); }

UART_Read_Text

Prototype	void UART_Read_Text(char Output, char* Delimiter, char* Attempts);
Returns	Nothing.
Description	Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter output; delimiter sequence is stored in the parameter delimiter. This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found). This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine. Parameters : Output: received text Delimiter: sequence of characters that identifies the end of a received string Attempts: defines number of received characters in which Delimiter sequence is expected. If Attempts is set to 255, this routine will continuously try to detect the Delimiter sequence.
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	Read text until the sequence “OK” is received, and send back what’s been received: UART1_Init(4800); // initialize UART1 module Delay_ms(100); while (1) { if (UART_Data_Ready() == 1) { // if data is received UART_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART_Write_Text(output); // sends back text } }

UART_Write

Prototype	void UART_Write(char data_);
Returns	Nothing.
Description	The function transmits a byte via the UART module. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine. Parameters : _data: data to be sent
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	unsigned char _data = 0x1E; ... UART_Write(_data);

UART_Write_Text

Prototype	void UART_Write_Text(char * UART_text);
Returns	Nothing.
Description	Sends text via UART. Text should be zero terminated. This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine. Parameters : UART_text: text to be sent
Requires	UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example	Read text until the sequence “OK” is received, and send back what’s been received: UART1_Init(4800); // initialize UART1 module Delay_ms(100); while (1) { if (UART_Data_Ready() == 1) { // if data is received UART_Read_Text(output, "OK", 10); // reads text until 'OK' is found UART_Write_Text(output); // sends back text } }

This program demonstrates a simple data exchange via UART. When PIC MCU receives data, it immediately sends it back. If PIC is connected to the PC (see the figure below), you can test the example from the mikroC PRO for PIC terminal for RS-232 communication, menu choice Tools › Terminal.

Code

char uart_rd;

void main() {

ANSEL = 0; // Configure AN pins as digital

ANSELH = 0;

UART1_Init(9600); // Initialize UART module at 9600 bps

Delay_ms(100); // Wait for UART module to stabilize

UART1_Write_Text("Start");

UART1_Write(10);

UART1_Write(13);

while (1) { // Endless loop

if (UART1_Data_Ready()) { // If data is received,

uart_rd = UART1_Read(); // read the received data,

UART1_Write(uart_rd); // and send data via UART

}

courtesy: microcontrollerprojects00.blogspot.in

tags: pic tutorial, serial communication tutorial, UART tutorial, UART sample circuits and programs, learn UART, learn PIC, PIC basics, Microcontroller Tutorial, Tutorial, PIC Tutorial, MikroC, PIC, MikroC, Embedded Tutorial, Microcontroller, Embedded

USB to Serial Converter using AVR microcontrollers

2012-10-09T08:22:00.000-07:00

This project is based on the AVR microcontrollers, which can be used to make a USB to Serial port converter based on Object Deveopment's V-USB (Software-USB on AVR), and the CDC (Communication Device Class) protocol was extended over it

The AVR-CDC converts USB and RS-232C signals using the AVR micro- controller which has no on-chip USB interface. . AVR-CDC enables PC to communicate with the USB device through virtual COM port.

The basic idea of using CDC protocol over Low-speed USB is based on Kyosuke Ishikawa's experiment in 2005. To make it stable and practical, Christian Starkjohann in Object Development helped me modifying his V-USB stack. Since three endpoints and the bulk transfer on low-speed device violates the USB standard, I added a tiny patch driver on Windows' USB stack.

Although this technology is quite experimental, it may be useful to interface your original system to PC easily.

Basically the circuit is very simple, but it requires a certain amount of skills to control. If you need practical or stable solutions, or you are not familiar with electronics nor installing drivers, use the dedicated chip from vendors like FTDI.

The back door to the low-speed bulk transfer is gradually closing on the newer OS. After enjoying this USB technology, switch to the HID protocol or to MCU having on-chip USB controller.

CDC-232

CDC-232 creates a virtual COM port on PC that doesn't have real RS- 232C port. It enables RS-232C communication (without control lines), after connecting the device and installing the driver.

Virtual COM Port over Software-USB

Usage

Write the program to AVR, build the circuit, and connect the device to PC's USB port. Install the driver on Windows. Access the device through generated virtual COM port from terminal software or your application. Control lines (DTR, DTS, RTS, CTS) are not used by the host application. Set the terminal software as "no flow-control".
Windows requests the driver installation again when connected to other USB port. Detect the previously installed driver automatically. Another COM number will be assigned. If you set serial number in AVR (rebuild with modified usbconfig.h), you can get the same COM port at any USB port. However, you cannot connect multiple CDC devices of the same serial number.
Before detaching the device, close the COM port in terminal software or in your application. Otherwise, you cannot connect to the device again because of the broken file handle. Restart the terminal software or your application then. Switch to the fast transfer mode using "lowcdc.vbs" to get the baudrate higher than 9600bps.

Loop-back test on ATtiny45 version

Schematics

These schematics are for ATtiny45/85, ATtiny2313/AT90S2313, and ATmega8/48/88/168. Their firmware are all ISP-programmable. The red LED drops the USB voltage from 5V to 3.3V, and provides to AVR. The current is about 10mA, and is not enough to drive other circuit. When connecting to other MCU, connect Gnd and connect TxD and RxD in crossing way. R4 limits the leak current when the MCU's Vcc is 5V. You can omit if the Vcc is equal. R5 protects the TxD pin when it shortened to Gnd. You can omit both R4 and R5 if you connect to the RS- 232C driver like MAX232. Use crystal oscillator. Although ceramic resonator works well in most cases, it becomes unstable if the frequency deviation is bigger.

CDC-232 for ATtiny45-20

ATtiny45/85 uses internal RC oscillator and PLL. It is calibrated by USB signal when connected. UART is implemented by software. It is not enough for high speed data transfer. If the TxD and the RxD are inverted (rebuild with -DUART_INVERT option), you can directly connect to RS-232C line. 1200 - 4800bps, 8N1

CDC-232 for ATtiny2313-20

ATtiny2313/AT90S2313 has 2KB program memory. Although the baudrate is configured automatically, some functions are omitted. 600 - 38400bps, 8N1

CDC-232 for ATmega8/48/88-20

ATmega8/48/88's internal UART is configured from the PC. The flow-control (RTS/CTS) is supported.
600 - 38400bps, data 7/8, parity N/E/O, stop 1/2

Schematics

CDC-232 for ATtiny45-20

CDC-232 for ATtiny2313-20

CDC-232 for ATmega8/48/88-20

Driver and code click here for CDC home page

courtesy : microcontrollerprojects00.blogspot.in

tags: Serial Communication, Uart Project, USB to RS 232 converter, USB projects, USB circuits, USB to UART, Embedded projects, AVR, Atmega8, RS 232projects, Atiny

Make your own Extra UART For Your PIC

2012-10-09T08:12:00.004-07:00

Software UART Library

The mikroC PRO for PIC provides routines for implementing Software UART communication. These routines are hardware independent and can be used with any MCU.
The Software UART Library provides easy communication with other devices via the RS232 protocol.

Important : The Software UART library implements time-based activities, so interrupts need to be disabled when using it.

Library Routines

Soft_UART_Init

Prototype	char Soft_UART_Init(char port, char* rx_pin, char tx_pin, unsigned long baud_rate, char inverted);
Returns	2 - error, requested baud rate is too low 1 - error, requested baud rate is too high 0 - successful initialization
Description	Configures and initializes the software UART module. Parameters : port: port to be used. rx_pin: sets rx_pin to be used. tx_pin: sets tx_pin to be used. baud_rate: baud rate to be set. Maximum baud rate depends on the MCU’s clock and working conditions. inverted: inverted output flag. When set to a non-zero value, inverted logic on output is used. Software UART routines use Delay_Cyc routine. If requested baud rate is too low then calculated parameter for calling Delay_Cyc exceeds Delay_Cyc argument range. If requested baud rate is too high then rounding error of Delay_Cyc argument corrupts Software UART timings.
Requires	Nothing.
Example	This will initialize software UART and establish the communication at 14400 bps: char error; ... error = Soft_UART_Init(&PORTC, 7, 6, 14400, 0); // Initialize Soft UART at 14400 bps

Soft_UART_Read

Prototype	char Soft_UART_Read(char * error);
Returns	Byte received via UART.
Description	The function receives a byte via software UART. This is a blocking function call (waits for start bit). Programmer can unblock it by calling Soft_UART_Break routine. Parameters : error: Error flag. Error code is returned through this variable. 0 - no error 1 - stop bit error 255 - user abort, Soft_UART_Break called
Requires	Software UART must be initialized before using this function. See the Soft_UART_Init routine.
Example	char data_, error; ... // wait until data is received do data = Soft_UART_Read(&error); while (error); // Now we can work with data: if (data_) {...}

Soft_UART_Write

Prototype	void Soft_UART_Write(char udata);
Returns	Nothing.
Description	This routine sends one byte via the Software UART bus. Parameters : udata: data to be sent.
Requires	Software UART must be initialized before using this function. See the Soft_UART_Init routine. Be aware that during transmission, software UART is incapable of receiving data – data transfer protocol must be set in such a way to prevent loss of information.
Example	char some_byte = 0x0A; ... // Write a byte via Soft UART Soft_UART_Write(some_byte);

Soft_UART_Break

Prototype	void Soft_UART_Break();
Returns	Nothing.
Description	Soft_UART_Read is blocking routine and it can block the program flow. Calling this routine from the interrupt will unblock the program execution. This mechanism is similar to WDT. Note : Interrupts should be disabled before using Software UART routines again (see note at the top of this page).
Requires	Nothing.
Example	char data1, error, counter = 0; void interrupt() { if (INTCON.T0IF) { if (counter >= 20) { Soft_UART_Break(); counter = 0; // reset counter } else counter++; // increment counter INTCON.T0IF = 0; // Clear Timer0 overflow interrupt flag } } void main() { OPTION_REG = 0x04; // TMR0 prescaler set to 1:32 ... if (Soft_UART_Init(&PORTC, 7, 6, 9600, 0) == 0) Soft_UART_Write(0x55); ... // try Soft_UART_Read with blocking prevention mechanism INTCON.GIE = 1; // Global interrupt enable INTCON.T0IE = 1; // Enable Timer0 overflow interrupt data1 = Soft_UART_Read(&error); INTCON.GIE = 0; // Global interrupt disable }

Example Program use two UART

/* This program inputs from on chip UART and output to Soft UART*/

char i, error, byte_read='1',uart_rd='1'; // Auxiliary variables

void main(){

TRISB = 0x00; // Set PORTB as output (error signalization)

PORTB = 0;

UART1_Init(9600); // No error

error = Soft_UART_Init(&PORTC,1 , 0, 9600, 0); // Initialize Soft UART at 14400 bps

if (error > 0) {

PORTB = error; // Signalize Init error

while(1) ; // Stop program

}

Delay_ms(100);

UART1_Write_Text("Enter Text Here (0 to exit)");

do {

if (UART1_Data_Ready()) {

UART1_Write(10);

UART1_Write(13);

uart_rd = UART1_Read();

Soft_UART_Write(uart_rd);

Delay_ms(100);

}

}while(uart_rd!='0');

}

tags: extra UART, circuit for extra UART, sample program for UART, UART circuit, PIC Tutorial, MikroC PIC Tutorial, Extra UART, 2 UART, Additional UART, Embedded Tutorial, Embedded

Using RB0 External Interrupt of PIC 16F877A

2012-10-09T08:05:00.002-07:00

This is a demonstration for the RB0 external interrupt of PIC 16F877A, below are features of the external interrupt that we are using.

An input ( depending on how we set it up ) on the RB0 triggers the interrupt, either the signal goes from 0 to 1, called the rising edge, or as the signal goes from 1 to 0, called the falling edge. This sets the interrupt flag, and if the interrupt is enabled ( and we are not already in an interrupt ) the microcontroller goes to the interrupt subroutine.

The use of the RB0/Int to should be clear that the use of RB0/Int function of a picmicro requires the setting of the:
GIE(7): set to 1 to enable global interrupts
INTE(4): set to 1 to enable interrupts on pin RB0
PEIE(6): to disable other periferal interrupts
and the set of the INTEDG bit(6) of the OPTION_REG register simply to select the rising or falling edge, of the signal.

When switch is pressed RB0 goes from 0 to 1 causing an interrupt which calls the interrupt() routine. The interrupt routine increment the value of PORD by one.

Code

void interrupt(void)

{

PORTD++; //Increment PORTD value by one

//delay_ms(500);

INTCON.INTF = 0; // clear the interrupt flag

}

void main(void)

{

TRISB = 0x01;

TRISD = 0x00;

INTCON.GIE = 1; //Enable Global Interrupt

INTCON.INTE = 1; //Enable RB0/INT external Interrupt

INTCON.PEIE = 0; //Disable all unmasked peripheral interrupt

OPTION_REG.INTEDG = 1; //Interrupt on rising edge

PORTD=0;

{

} while(1);

}

tags: PIC, PIC 16F877A, PIC 16F877A circuits, PIC 16F877A external interupt, PIC 16F877A projects, MikroC PIC Tutorial, pic interrupt, PIC Microcontroller Interrupt, MikroC, Microcontroller

DFT and IDFT using MATLAB

2012-09-17T10:36:00.002-07:00

AIM:

To find DFT and IDFT of a sequence.

APPARATUS REQUIRED:

Hard ware: IBM PC or compatible

Soft ware : Matlab 6.5 or higher

THEORY:

In mathematics, the discrete Fourier transform (DFT) is a specific kind of discrete transform, used in Fourier analysis. It transforms one function into another, which is called the frequency domain representation, or simply the DFT, of the original function (which is often a function in the time domain). The DFT requires an input function that is discrete. Such inputs are often created by sampling a continuous function, such as a person's voice. The discrete input function must also have a limited (finite) duration, such as one period of a periodic sequence or a windowed segment of a longer sequence. Unlike the discrete-time Fourier transform (DTFT), the DFT only evaluates enough frequency components to reconstruct the finite segment that was analyzed. The inverse DFT cannot reproduce the entire time domain, unless the input happens to be periodic. Therefore it is often said that the DFT is a transform for Fourier analysis of finite-domain discrete-time functions.

FFT algorithms are so commonly employed to compute DFTs that the term "FFT" is often used to mean "DFT" in colloquial settings. Formally, there is a clear distinction: "DFT" refers to a mathematical transformation or function, regardless of how it is computed, whereas "FFT" refers to a specific family of algorithms for computing DFTs. The terminology is further blurred by the (now rare) synonym finite Fourier transform for the DFT, which apparently predates the term "fast Fourier transform"

The discrete Fourier transform (DFT) is given by:

The inverse discrete Fourier transform (IDFT) is given by:

PROGRAM:

clc;

clear all;

close all;

x=input('enter the sequence');

x1=fft(x);

subplot(2,2,1);

stem(imag(x1));

title('imaginary fft');

disp('fft');

disp(x1);

subplot(2,2,2);

stem(real(x1));

title('real fft');

y=ifft(x1);

subplot(2,2,3);

stem(imag(y));

title('imaginary ifft');

disp('ifft');

disp(y);

subplot(2,2,4);

stem(real(y));

title('real ifft');

Enter the sequence [1 2 3 4]

Tags: MATLAB basics, MATLAB programs, MATLAB signal generation, Learn MATLAB, IDFT, DFT, IDFT using MATLAB, DFT using MATLAB, IDFT programs, DFT programs, IDFT and DFT programs

Two-digit LED counter using PIC

2012-09-17T10:20:00.004-07:00

Here the PIC16F887 is used as a two-digit counter . The variable i is incremented (slow enough to be visible) and its value is displayed on a two-digit LED display (99-0). The challenge is to enable a binary number to be converted in decimal and split it in two digits (tens and ones). Since the LED display segments are connected in parallel, it is necessary to ensure that they change fast in order to make impression of simultaneous light emission (time-division multiplexing).

In this example, timer TMR0 is in charge of the time-division multiplexing, while the mask function converts a binary number into decimal format.

/*Header******************************************************/
    
unsigned short mask(unsigned short num);
unsigned short digit_no, digit10, digit1, digit, i;

void interrupt() {
    if (digit_no==0) {
        PORTA = 0;                 // Turn off both displays
        PORTD = digit1;            // Set mask for displaying ones on PORTD
        PORTA = 1;                 // Turn on display for ones (LSD)
        digit_no = 1;
    } else {
        PORTA = 0;                 // Turn off both displays
        PORTD = digit10;           // Set mask for displaying tens on PORTD
        PORTA = 2;                 // Turn on display for tens (MSD)
        digit_no = 0;
    }
    TMR0 = 0;                      // Reset counter TMRO
    INTCON = 0x20;                 // Bit T0IF=0, T0IE=1
}

void main() {
    OPTION_REG = 0x80;             // Set timer TMR0
    TMR0 = 0;
    INTCON = 0xA0;                 // Disable interrupt PEIE,INTE,RBIE,T0IE
    PORTA = 0;                     // Turn off both displays
    TRISA = 0;                     // All port A pins are configured as outputs
    PORTD = 0;                     // Turn off all display segments
    TRISD = 0;                     // All port D pins are configured as outputs
    
    do {
        for (i = 0; i<=99; i++) {  // Count from 0 to 99
            digit = i % 10u;
            digit1 = mask(digit);  // Prepare mask for displaying ones
            digit = (char)(i / 10u) % 10u;
            digit10 = mask(digit); // Prepare mask for displaying tens
            Delay_ms(1000);
        }
    } while (1);                   // Endless loop
}

mask.c file:

/*Header******************************************************/
unsigned short mask(unsigned short num) {
switch (num) {
case 0 : return 0x3F;
case 1 : return 0x06;
case 2 : return 0x5B;
case 3 : return 0x4F;
case 4 : return 0x66;
case 5 : return 0x6D;
case 6 : return 0x7D;
case 7 : return 0x07;
case 8 : return 0x7F;
case 9 : return 0x6F;
}
}

LCD based digital alarm clock using 89S51 MC

2012-09-16T10:31:00.001-07:00

LCD based digital alarm clock using 89S51 MicroController

Circuit Diagram

An alarm clock is a clock that indicates a pre-set time by producing sound at that time. This functionality of digital clock is used to awaken people or remind them of something. A digital clock is one that displays time digitally. The project explained here, displays time on a 16x2 LCD module. The LCD is interfaced with 8051 microcontroller (AT89S51). This circuit can be used in cars, houses, offices etc.

Read Full Article

Tags: microcontroller projects, digital alarm, 89S51 microcontroller, 89S51 microcontroller projects, 89S51 microcontroller circuits, project circuits

PIC Serial Communication Tutorial (UART)

2012-09-16T10:19:00.003-07:00

Circuit

Read Full Article

Presentation Topics on POWER GENERATION FROM ROAD SPEED BREAKER AND FROM SHOES

2012-09-15T22:10:00.003-07:00

Energy is subject to the law of conservation of energy. According to this law, energy can neither be created (produced) nor destroyed by itself. It can only be transformed.
Most kinds of energy (with gravitational energy being a notable exception)^[10] are subject to strict local conservation laws as well. In this case, energy can only be exchanged between adjacent regions of space, and all observers agree as to the volumetric density of energy in any given space. There is also a global law of conservation of energy, stating that the total energy of the universe cannot change; this is a corollary of the local law, but not vice versa.^[6]^[11] Conservation of energy is the mathematical consequence of translational symmetry of time (that is, the indistinguishability of time intervals taken at different time)^[12] - see Noether's theorem.
According to Conservation of energy the total inflow of energy into a system must equal the total outflow of energy from the system, plus the change in the energy contained within the system.
This law is a fundamental principle of physics. It follows from the translational symmetry of time, a property of most phenomena below the cosmic scale that makes them independent of their locations on the time coordinate. Put differently, yesterday, today, and tomorrow are physically indistinguishable.
This is because energy is the quantity which is canonical conjugate to time. This mathematical entanglement of energy and time also results in the uncertainty principle - it is impossible to define the exact amount of energy during any definite time interval. The uncertainty principle should not be confused with energy conservation - rather it provides mathematical limits to which energy can in principle be defined and measured.
Researches show that the world has already had its enough shares of its energy resources. Fossil fuels pollute the environment. Nuclear energy requires careful handling of both raw as well as waste material. The focus now is shifting more and more towards the renewable sources of energy, which are essentially, nonpolluting.

presentation Topics on recent trends in power generation

Energy conservation is the cheapest new source of energy. It is an attractive technology for optimal use of available sources. This project attempts to show how energy can be tapped and used at a commonly used system, the road-speed breakers. The number of vehicles passing over the speed breaker in roads is increasing day by day. There is possibility of tapping the energy and generating power by making the speed breaker as a power generation unit.

The generated power can be used for the lamps near the speed breakers.

Hence, a project work has been done in our institution, implementing this idea practically under the title “Design and Development of Power Generation Unit in Speed Breakers”. This project explains clearly, the working principle of the designed system, its practical implementation, and its advantages.

Power generation with shoe

Design of each component has been carried out using standard procedures, and the components have been fabricated and assembled. A similar model of the system has been modeled using Pro-E. Practical testing of the system has been done with different loads at different speeds. Taking the various criteria that determine the power generation, graphs have been plotted. The second project will show you how to create a shoe that generates electricity. It does this by using your energy when you walk and converts it into electricity. Its just a simple craft that every one should know it.

Read Full Article

Mains Failure Alarm

2012-09-15T21:52:00.002-07:00

This is a simple circuit diagram of a mains failure alarm. This circuit generates alarm when there is any failure in the main supply. So it can used as a safety alarm at the time of mains failure.

Tags: electronics circuits, electronics circuit ideas, circuit ideas, safety circuits, circuits for beginners, alarm circuits, mains failure alarm, mains failure alarm circuits, simple circuits, safety alarm

PIC Microcontroller Based Electronic Lock

2012-09-11T10:37:00.001-07:00

Security is a prime concern in our day-today life. Everyone wants to be as much secure as possible. An access control for doors forms a vital link in a security chain. The microcontroller based digital lock for Doors is an access control system that allows only authorized persons to access a restricted area.

An electronic lock or digital lock is a device which has an electronic control assembly attached to it. They are provided with an access control system. This system allows the user to unlock the device with a password. The password is entered by making use of a keypad. The user can also set his password to ensure better protection. The major components include a Keypad, LCD and the controller PIC16F877A. This article describes the making of an electronic code lock using the 16F877A microcontroller.

For complete circuit and description click on the link below

http://microcontrollerprojects00.blogspot.in/2012/03/pic-microcontroller-based-electronic.html

Tags: microcontroller projects, electronic projects, final year engineering projects, electronics mini projects, engineering projects, electronics circuits, microcontroller based projects, embeded projects, PIC projects, PIC circuits , Security locks, lock circuits, security circuits, electronic lock, microcontroller lock, electronic lock witth PIC, digital lock, digital security systems, PIC16F877A projects, PIC16F877A