Tuesday, 21 July 2015

RF REMOTE..

Want to make everything wireless..??? Huh.!! Then u r at right place. There are many wireless technologies like ir,DTMF,rf etc of these IR and DTMF are covered in earlier posts. So now its time for radio frequency communication.. Dont be get puzzled
In this post I will direct you how make simple RF remote..
So for making remote,components that you required are
*HT121D
*HT121E
*RX TX MODULES
*1.1M ohm resistor
*55k ohm resistor

Now its time to know about encoders and decoders.encoders is a thing which creates some data at transmitter end. Decode is opposite for those encoders it simply decode the data which has been transmitted by encoders..so from this we conclude that encoders should always lies at transmitting section and decoders lie at receiver section

MAKING A TRANSMITTER:




MAKING A RECEIVER:



This is how rf MODULES looks












Monday, 20 July 2015

ADC....¡¡

The Analog World

Microcontrollers are capable of detecting binary signals: is the button pressed or not? These are digital signals. When a microcontroller is powered from five volts, it understands zero volts (0V) as a binary 0 and a five volts (5V) as a binary 1. The world however is not so simple and likes to use shades of gray. What if the signal is 2.72V? Is that a zero or a one? We often need to measure signals that vary; these are called analog signals. A 5V analog sensor may output 0.01V or 4.99V or anything inbetween. Luckily, nearly all microcontrollers have a device built into them that allows us to convert these voltages into values that we can use in a program to make a decision.

What is the ADC?

An Analog to Digital Converter (ADC) is a very useful feature that converts an analog voltage on a pin to a digital number. By converting from the analog world to the digital world, we can begin to use electronics to interface to the analog world around us.
alt text
Not every pin on a microcontroller has the ability to do analog to digital conversions. On the Arduino board, these pins have an ‘A’ in front of their label (A0 through A5) to indicate these pins can read analog voltages.
ADCs can vary greatly between microcontroller. The ADC on the Arduino is a 10-bit ADC meaning it has the ability to detect 1,024 (210) discrete analog levels. Some microcontrollers have 8-bit ADCs (28 = 256 discrete levels) and some have 16-bit ADCs (216= 65,535 discrete levels).
The way an ADC works is fairly complex. There are a few different ways to achieve this feat (see Wikipedia for a list), but one of the most common technique uses the analog voltage to charge up an internal capacitor and then measure the time it takes to discharge across an internal resistor. The microcontroller monitors the number of clock cycles that pass before the capacitor is discharged. This number of cycles is the number that is returned once the ADC is complete.

Relating ADC Value to Voltage

The ADC reports a ratiometric value. This means that the ADC assumes 5V is 1023 and anything less than 5V will be a ratio between 5V and 1023.
alt text
Analog to digital conversions are dependant on the system voltage. Because we predominantly use the 10-bit ADC of the Arduino on a 5V system, we can simplify this equation slightly:
alt text
If your system is 3.3V, you simply change 5V out with 3.3V in the equation. If your system is 3.3V and your ADC is reporting 512, what is the voltage measured? It is approximately 1.65V.
If the analog voltage is 2.12V what will the ADC report as a value?
alt text
Rearrange things a bit and we get:
alt text
alt text
Ahah! The ADC should report 434.

Arduino ADC Example

To show this in the real world let’s use the Arduino to detect an analog voltage. Use a trimpot, or light sensor, or simple voltage divider to create a voltage. Let’s setup a simple trimpot circuit for this example:
alt text
To start, we need to define the pin as an input. To match the circuit diagram we will use A3:
pinMode(A3, INPUT);
and then do the analog to digital version by using the analogRead() command:
int x = analogRead(A3); //Reads the analog value on pin A3 into x
The value that is returned and stored in x will be a value from 0 to 1023. The Arduino has a10-bit ADC (210 = 1024). We store this value into an int because x is bigger (10 bits) than what a byte can hold (8 bits).
Let’s print this value to watch it as it changes:
Serial.print(“Analog value: “); Serial.println(x);
As we change the analog value, x should also change. For example, if x is reported to be 334, and we’re using the Arduino at 5V, what is the actual voltage? Pull out your digital multimeter and check the actual voltage. It should be approximately 1.63V. 

Number conversation.. ¿¿

When we write numbers, we have ten different digits that we can put in each place (0-9). After that we need to add a new column of digits and we keep going. This is called the decimal system (or base 10). What would happen if instead of using ten digits we used eight, or two, or even sixteen? Well, what happens is instead of a decimal system we would have what's called binary, octal, or hexadecimal systems (base 2, base 8, and base 16). We use subscripts to denote the system we are using: 987610 is decimal (if we don't use a subscript we assume we are using decimal), 76538 is octal, 10102 is binary, and BEEF16 isyummy hexadecimal.
Binary – binary just has 1s and 0s. But much of our world is binary. Light switches are either up or down, your computer is either on or off, our servers are either currently up or down (hopefully up). Because computers are made up of billions of little switches (called transistors), they do calculations in binary. Everything in your computer is either on or off. And so we represent larger numbers in 1s and 0s. Each 1 or 0 is called a bit, and 8 bits is a byte.
Octal – at some point we end up with a lot of 1s and 0s and they are kind of hard to read. For example "010101000110100001100101" and that’s just to spell "The.”  But if we break that into 3 piece sections with 8 possible digits it becomes 250641458 which is a little easier to read. And thus we have octal.  Unfortunately for octal we rarely use it.
Hexadecimal – What happens if we break that down into 4 piece sections? Well, first of all we run out of digits because now we have 16 possible digits instead of our normal 10. Sothe powers that be just decided to start using letters so hexadecimal has 16 digits (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F). In other words if we wanted to write 1010 we would write A16etc.  Now if we want to write out the word "the" it looks like 54686516 which is a whole lot easier to read.
Decimal ValueHex ValueBinary Value
00x000000
10x010001
20x020010
30x030011
40x040100
50x050101
60x060110
70x070111
80x081000
90x091001
100x0A1010
110x0B1011
120x0C1100
130x0D1101
140x0E1110
150x0F1111
Conversion – In decimal, the least significant digit (the one on the right) keeps track of 100. The next column is 101, then 102 etc.
So 382 is
(2 x 100)+ (8 x 101) + (3 x 102) = 2 + 80 + 300.
The same is true for other systems.
For example, 1011111102 goes thusly:
(0 x 20) + (1 x 21) + (1 x 22) + (1 x 23) + (1 x 24) + (1 x 25) + (1 x 26) + (0 x 27) + (1 x 28) =
0 + 2 + 4 + 8 + 16 + 32 + 64 + 0 + 256 = 38210
Now you try (highlight for answers):
BEED16
D x 160 = 13 x 1 = 13
E x 161 = 14 x 16 =224
E x 162 = 14 x 256 =3584
B x 163 = 11 x 4096 =45056
Add that up and you get: 4887710
And remember just because things have bytes does NOT mean you should bite them. None of our products should be ingested or inserted under the skin.