Techila

Persistence of Vision

2011-10-27T13:13:00.002+05:30

Our eyes have a property of persistence of vision. It means that an after-image persists even after the original image no longer exists. This after-image persists for approximately 1/25 th of a second.
So let's say, there are some red LED. The LED blink one after another with a gap of, say, 1 second. In this case I will be able to notice a change in the state of the LED, that is whether it is ON or OFF, as shown in the video below:

Now, say I reduce this time gap to about 500 milliseconds. This is what will happen:

If I further reduce the time gap, this is what it will look like:

In the next video the time gap is of the order of micro-seconds.

So, you see, in each of the above cases, I was turning ON only one LED at a time, but as the time delay between turning ON and turning OFF reduced, all the LED seemed to be ON at a time, forming the smiley figure in the last video.
This method is used in all LED displays you might have seen, on the buses, or the railway station..etc.

Instead of the 8x8 LED matrix used above, we could also use a row of LED.
--> For a single row of LED

Look at the diagram below.
t1, t2..t7 have units of time. So, at each t1,t2 etc, the state of the LED will change.

Now, to display a smiley face:

Thus, at time t1, display nothing. Then at t2,t3,t4,t5,t6 display as shown in the picture.
For example, the code for the smiley face will be:

#include<avr/io.h>
#include<util/delay.h>
void main()
{ DDRC=0xff; // making PortC as output port
while(1)
{
PORTC=0x00; // at t1;
_delay_us(10);

PORTC=0b00001000; // at t2 , note that the last row in PC7 and the first row in PC0
_delay_us(10);

  PORTC=0b00010010; // at t3
   _delay_us(10);

PORTC=0b00010000; // at t4
   _delay_us(10);

PORTC=0b00010010; // at t5
   _delay_us(10);

PORTC=0b00001000; // at t6
_delay_us(10);

PORTC=0x00; // at t7
_delay_us(10);
}
}
// we can ignore t8 here as it is not required. t7 was included to
//make sure that there was sufficient space between smileys.

Now, all we need to do is move it at a high speed. Since, I couldn't find a cheap enough high rpm motor. I stuck the circuit up on my fan, the result was this :

Circuit board on the fan

Smile!!

Yeah, I know, the characters look a little stretched. To correct that you'll have to adjust the delay period.

One more pic:

The characters appear to be reversed because I did not take into account the direction of rotation of the fan.

Follow Techila on facebook.

So, until next time.. Sayōnara!

A Robotic Arm

2011-10-19T16:11:00.000+05:30

I wrote just the code for controlling this robot. The mechanical structure isn't mine. It had 3 degrees of motion. The robot was already assembled. The controlling chip was an ATMega16. A Potentiometre was used to sense the movement of the arm, potentiometers were used. One was used to indicate movement of the finger, other for sensing the movement of the wrist and the last one to check for the movement of the elbow.

In this video we are simply rotating the potentiometer to control the arm. Watch how it almost falls over.

Visit us on Facebook.

Bbye! :)

Making a Microcontroller Circuit on a Veroboard

2011-10-08T20:38:00.000+05:30

Most competitions do not allow use of development boards. In these cases you need to make your own circuit on a veraboard or a breadboard. A veraboard is a much suitable option.

In this post we will be making a basic circuit for an AVR Micro-controller without any peripherals.

Items you will need:

1) Veroboard

Top side of the Veroboard. Soldering is done on the bottom side.

2) IC Holder

40 Pin IC Base for ATMega16

3) 2 Capacitors- 22pF each

4) 1 Capacitor- 100nF

5) A crystal to function as an external clock. Several are available, I used a 16
MegaHz crystal.

6) A voltage regulator IC 7805

7) The most important of them all, a Microcontroller (ATMega16 used here)

Now, pins like XTAL1, XTAL2, AREF, AVCC, GND, VCC, RESET are common to all microcontrollers. They may be present with a slightly different name in some, but are present in all.

Consider the pin diagram of an ATMega16

The crystal is connected at Pin number 12 and 13, i.e XTAL2 and XTAL13. Connect one end (any) of the crystal at Pin 12 and the other at Pin 13

Pin number 32 (AREF) is connected to a 100nF capacitor which is then connected to ground.

Pin 10 (VCC) and pin 30 (AVCC) are shorted. Pin 10 (VCC) is connected to a 5 Volt supply.

Pin 31 (GND) and Pin 11 (GND) are shorted and connected to ground.

A Voltage Regulator IC LM7805 is used. The positive terminal of the battery is connected to input of 7805, the negative is connected to middle pin of 7805 and the 3rd pin gives regulated output of 5 V for input voltage greater that 7.5 Volt.

Now, get the Veroboard out. The side shown in the picture in the beginning is the top side. No soldering is done on this side. Soldering is done below it.

First, on a rough sheet make a plan of the circuit you want to make.

Next, place the IC base at an appropriate position. If you are connecting some other components like IR LED, buzzer etc. on both sides of the Microcontroller, it is best to place the IC base in the middle. If, let's say the peripheral components are to be connected only on the right side, place your IC base on the extreme left of the veroboard, giving just enough space to place and connect a capacitor.

Once the IC base position has been decided, short (connect) Pin 10 (VCC) and Pin 30 (AVCC).

Then, short (connect) Pin 11 (GND) and Pin 31 (GND).

Make sure that the VCC and GND pins do not come in contact with each other!

Next, place the crystal and connect one of it's legs to XTAL2 and the other to XTAL1.

Then, to each leg of the crystal connect a 22pF capacitor and ground the other end of the capacitor.

Place the LM7805 IC on the veroboard.

Note: With the flat side facing away from you, it's I-G-O, i.e Input-Ground-Output

Connect the +ve terminal of the battery or the power-supply to Input pin of LM7805.

Connect the GND pin of LM7805 to the GND of the battery or the power-source.

This GND is also connected to Pin 31 and Pin 11 of the Microcontroller.

Also note, all the GND points on the circuit should be linked to each other which is finally connected to the GND (or the -ve) of the power-supply.

Connect the output pin of LM7805 to Pin 10 and Pin 30. This pin gives the 5V output supply.

The circuit will finally look like this:

Adios until next time! :)

Image Processing (Acquisition)

2011-10-04T23:16:00.001+05:30

In this post we will talk about Image Acquisition and processing using Matlab.

A digital image is composed of 'pixels' which can be thought of as small dots on the screen. A typical size of an image is 512-by-512 pixels. Later on in the course you will see that it is convenient to let the dimensions of the image to be a power of 2. For example, 2⁹=512. In the general case we say that an image is of size m-by-n if it is composed of m pixels in the vertical direction and n pixels in the horizontal direction.

Matlab has an Image Acquisition Tool Box which can be used for acquiring

images.

To open the toolbox, click on start -->

Toolboxes ---> Image Acquisition ---> Image Acquisition Tool (imaqtool)

Once the Image Acquisition ToolBox is open, you could start preview, view the type of camera you are using etc.

You could also do all this using MATLAB commands.

Plug in a camera to your laptop.
In the Workspace, type:
imaqhwinfo
and hit enter.

You will get an output something like this:

>> imaqhwinfo

ans =

InstalledAdaptors: {'coreco' 'winvideo'}
MATLABVersion: '7.6 (R2008a)'
ToolboxName: 'Image Acquisition Toolbox'
ToolboxVersion: '3.1 (R2008a)'

Thus by using this command we can know the adapters installed.

Now, we want to capture the video, right?
There is a command in MATLAB called 'videoinput'. It helps you to create video input objects.
Syntax:

OBJ = VIDEOINPUT(ADAPTORNAME)
OBJ = VIDEOINPUT(ADAPTORNAME,DEVICEID)
OBJ = VIDEOINPUT(ADAPTORNAME,DEVICEID,FORMAT)
OBJ = VIDEOINPUT(ADAPTORNAME,DEVICEID,FORMAT,P1,V1,...)

We already got the adapter name by using the imaqhwinfo command. Winvideo and Coreco are the name of the installed adapters. Any one of them can be used.
For format, open the Image Acquisition Toolbox, it will be mentioned on the left side of the toolbox. The camera I was using was a 'YUY2_352x288'.
In the workspace again type imaqhwinfo(write name of your adapter here) and hit enter, this will give you the device id.

>> imaqhwinfo('winvideo')

ans =

AdaptorDllName: 'C:\Program Files\MATLAB\R2008a\toolbox\imaq\imaqadaptors\win32\mwwinvideoimaq.dll'
AdaptorDllVersion: '3.1 (R2008a)'
AdaptorName: 'winvideo'
DeviceIDs: {1x0 cell}
DeviceInfo: [1x0 struct]

Thus, the device id is 1.

So, my videoinput statement becomes something like this:

obj=videoinput('winvideo',1,'YUY2_352x288');

Next --> triggerconfig
This command is used to configure the trigger settings of the video input object. i.e it defines how you want the camera to trigger, whether it should be manual or auto.
We define it manual because we want it to start only when we need it.
remember that 'obj' is the video input object we have defined.

thus, my command statement looks like this:
triggerconfig(obj,'manual');

Now, we need to set the number of frames we want the camera to capture every time it's triggered. For my use i set it to 1. Also, the triggering should happen continuously, thus it should also be set to infinity.

set(obj,'FramesPerTrigger',1);
set(obj,'TriggerRepeat',inf);

after that start(obj) initializes 'obj' which is the object defined for videoinpout.

If you want to preview the video during run-time, give the command preview(obj) after start(obj).

Thus our code in MATLAB till now is:

obj=videoinput('winvideo',1,'YUY2_352x288');
triggerconfig(obj,'manual');
set(obj,'FramesPerTrigger',1);
set(obj,'TriggerRepeat',inf);
start(obj);
preview(obj);

To trigger the camera the command: trigger(obj), is used.
use the getdata command to get data and store it in a variable
im=getdata(obj,1);

Thus, now we have one image stored in im.

I recently took part in a competition in which I had to follow a red line by using a web-cam to see the line.
In such a case, the image that was obtained contained a red line on a white background. The preview window (which you get by using the preview(obj) command) looks like this :

This image needs to be converted into grayscale image first. A grayscale image represents an image as a matrix where every element has a value corresponding to how bright/dark the pixel at the corresponding position should be colored.
the command rgb2gray is used to conver the image to grayscale.
The camptured image is stored in im.
thus,
b=rgb2gray(im);
Now, b stores the grayscale image.
Below are shown two grayscale images with index intensity values for the RED portion and the WHITE area.

Thus we see that there is a difference between the index values of WHITE and RED.
A function roicolor() can be used to definitely separate red and white by specifying a range of threshold index value. All values within that range will show as white and values outside that range will show as black.

a=roicolor(b,[100,115]);

The black portion in between the white strip where the red tape was is because of there was a high intensity reflection of the room light (see in preview image above)

Now we invert the image, i.e make the black region white and white region black, so that the region of interest shows up more clearly.

Now that we have this image, we calculate the centre of gravity of the black portion of the image. If the centre of gravity lies near the centre of the image, we send instruction to our robot to keep moving forward, else the centre of gravity lies somewhere on the right side, the bot should move right and similarly for moving left side. The range of centre of gravity needs to be decided by us. For my use, I specified that if the x coordinate of the centre of gravity was between 140 and 180 the robot should move straight, if it was above that the robot should move right else left.

The instructions were sent to the microcontroller using UART communication.
The serial port can be configured in MATLAB using these commands:

ser= serial('COM42','BaudRate',9600,'DataBits',8);
fopen(ser);

The command fwrite(ser,'character') can be used to transmit data using UART.

At the end of the code, the serial port has to be closed and the videoinput object closed. My final code looked like this:

clc;
clear all;
close all;
obj=videoinput('winvideo',1,'YUY2_352x288');
triggerconfig(obj,'manual');
set(obj,'FramesPerTrigger',1);
set(obj,'TriggerRepeat',inf);
start(obj);
ser= serial('COM42','BaudRate',9600,'DataBits',8);
fopen(ser);
while(1) % infinite loop

trigger(obj);
im=getdata(obj,1); %get the image

trigger(obj);
im1=getdata(obj,1); % the first time triggering occurs the image is just
% noise. Thus the 2nd image is used.
b=rgb2gray(im1); % convert to grayscale
a=roicolor(b,[100:118]); %define a region of interest
a=~a;

c=center(a);
% use disp(c) to see the values, while testing
if (c(2)>190)
fwrite(ser,'r'); % send move right
elseif (c(2)<170 && c(2)>10)
fwrite(ser,'l');
elseif c(2)<170
fwrite(ser,'l'); % stop

end
end
fclose(ser);
stop(obj),delete(obj),clear obj;
-------

The function center(a) that I have used is not an inbuilt function. I would suggest you attempt to write it on your own.

This is the video of the robot following the red line.

Analog to Digital Converter (ADC)

2011-06-08T13:16:00.004+05:30

(Circuit for IR Sensor for a Line Follower given at the end of the post)
Q1) What is an analog signal?

In simple words, Any signal that looks like this
is called an analog signal.

For example, if we were to plot the amplitude variation of a song with time, it would be an analog signal.
(The picture on the right is a part of amplitude variation of an actual song)

Q2) What is a digital signal?

Any signal that would look like this
is called a digital signal.




The main difference between an analog signal and digital signal is that a digital signal will keep fluctuating between two fixed values i.e it will take no other value, whereas an analog signal has no such conditions.
The 'high' part of the digital signal is usually represented with a 1 and the low part with a 0.
The high part can be anything, but it must be fixed throughout. Generally, the high part should be at 5 Volts and the low part is at 0 Volt.
The process of converting an analog signal to a digital signal is called an analog to digital conversion.

It is recommended that you have the datasheet open in front of you before reading further.
Datasheets for
1) ATMega16
2) ATMega32

Now, the MEGA series of AVR Microcontrollers (like ATMega16, ATMega32 etc) have an inbuilt ADC.
ATMega16 and ATMega32 have 8 ADC channels on PortA with PA0 being the first ADC channel and PA7 being the 8th ADC channel
The analog signal should be given at one of these channels. The analog signal is a simply varying analog signal, which can also be produced by simply making a voltage divider circuit. The circuit is shown at the end of the blog post.

Now, in the datasheet open the section for Analog to Digital Converter. Keep scrolling down till you come to ADC Multiplexer Register (ADMUX)

The register configuraton for ADMUX is as given below:

REFS1, REFS0 :
Now, bit 7 and bit 6 are the Reference Selection bits. The configuration of these bits is based on these conditions:

Note: AREF pin is pin number 32 in both ATMega16 and ATMega32

Let's assume that AREF is connected through a capacitor to ground.

Now, ATMega16/32 has a 10-bit ADC. This means that the maximum value that we can get is :
2¹⁰-1 = 1023

The microcontroller takes samples of the incoming analog signal at a specific frequency. The frequency is defined by us. We'll come to that a little later.
These samples are then converted to a digital value and stored in a 16 bit register called ADC Data Register. This register is made up of two 8-bit registers: ADCH (for storing the higher 8-bits) and ADCL ( for storing the lower 8-bits)
Since, it is a 10-bit ADC, by default, the lower 8 bits of the result is stored in ADCL and the most significant 2 bits are stored in ADCH.

ADLAR: ADC Left Adjust Result
If ADLAR=0, the result is stored in ADCH and ADCL as explained above and shown diagrammatically below.

if ADLAR is set to 1, the result is left adjusted, that means, the result is shifted towards the left by 8 places. This is a configuration.
It is shown below.

Note this carefully, the ADC data register will be updated only after ADCH is read. Thus it is necessary to read the ADCH data register in the program.
Note: When we say read ADCH, it implies a C code statement like, k=ADCh, here k is some variable.
Thus, if we can manage with 8 bit precision (value till 255), we left adjust the result, and read only ADCH, it makes programming easier. Otherwise, ADCL must be read first and then ADCH.
Hence, by setting ADLAR=1, we get an 8 bit ADC instead of 10 bit ADC.
Thus, let ADLAR=1;
The remaining bits are used to select which ADC channel we are using. for example if we are using PA0, the last 5 bits will have ( 00000), similarly, if we are using PA1, the last 5 bits will have the value ( 00001 ). This is shown in the table below.

Thus, the ADMUX register can be defined as

ADMUX=0b01100000; // if PA0 is the input

Next register of importance is ADCSRA register.

ADCSRA : ADC Control and Status Register

ADEN : ADC Enable
Write this bit to 1 to enable ADC. If this bit is made 0 at any time, even when the conversion is going on, will turn off the ADC and terminate the conversion
ADSC: ADC Start conversion
This bit is set to 1 to start conversion.
These bit values need to be set outside the infinite loop. And then again inside the infinite loop. When it is set outside the infinite loop, a conversion is performed, which initializes the ADC.
ADSC will read as 1 as long as conversion is progress. When the conversion is over it becomes 0.
No other operation should take place on the ADC while the conversion is in pogress. This, we write a code to wait till ADSC==1;
ADATE: ADC Auto trigger enable
In Auto trigger mode, we need to provide a triggering signal. If ADATE bit is set to 1, the ADC will start a conversion on the positive edge of the selected trigger signal.
ADIF: ADC Interrupt flag
When the conversion is complete, an interrupt occurs and this bit is set to 1. The user needs to clear this bit after the interrupt occurs. To use any interrupts it is essential that global interrupts are enabled using the command sei();
ADIE: ADC Interrupt Enable.
This bet is set to 1 by the user to enable ADC Interrupt.

ADPS2, ADPS1, ADPS0: Prescalar Bits.
Remember we were earlier talking about selecting the sampling frequency? Well, these are the bits that are used to select the sampling frequency.

Note: Nyquist criterion states the the sampling frequency must be twice the maximum frequency content of the signal. But, this is important mainly when the signal has to be reconstructed or some action needs to be performed utilizing the frequency of the incoming signal, e.g an Audio Signal. In cases like line follower sensors, there is no need to go by the Nyquist Criterion. Because we simply need to sample the incoming values

ADC Sampling frequency = (Clock Frequency of the Microcontroller/Division Factor)

Set these bits to (000) outside the infinite loop. Set to (001 or above as required) inside the infinite loop or just set it to (001 or above) outside the infinite loop itself.

Now, we write the sample code, assuming that I have only one input connected at PA0

#include<avr/io.h>

#include<util/delay.h>

unsigned char k;

void main()

{

ADMUX=0b01100000; // setting ADLAR to 1

ADCSRA=0b11000001;

while(1)

{ ADCSRA|=(1<<ADSC); // start conversion

while(ADCSRA&(1<<ADSC)); // wait here till ADSC is 1

k=ADCH; // conversion is complete, store the result in a variable.

/* Once we have the ADC value stored, we can do whatever further is required, compare, display etc.

}

Please note that at one instant of time only one ADC channel can be used.

Now, what if we have to use multiple ADC Channels??

In this case we will enable one channel, store the ADC value, then disable it and enable another channel.

Since, this process happens in a matter of micro-seconds, in 'human' terms, all the channels are being sampled nearly simultaneously.

Code to use multiple ADC Channels

Assuming that one analog input is at PA0 and another at PA1.

#include<avr/io.h>
#include<util/delay.h>

void main()

{

ADMUX=0b01100000; // setting ADLAR to 1, initially selecting PA0

ADCSRA=0b11000001;

while(1)

{ ADMUX=0b01100000; // select PA0

ADCSRA|=(1<<ADSC); // start conversion

while(ADCSRA&(1<<ADSC)); // wait here till ADSC is 1

k=ADCH;

ADMUX=0b01100001; // select PA1

ADCSRA|=(1<<ADSC); // start conversion

while(ADCSRA&(1<<ADSC)); // wait here till ADSC is 1

l=ADCH;

// Similarly repeat for as many (max. 8) channels required.

}

You can build a simple Voltage divider circuit to learn ADC.

For a voltage divider circuit, the output voltage (Vout) when converted to decimal will give a result (d) which can be calculated using the formula:

((Vout)x(Vref)/(255) )=d
Vref here is 5V.
For 8 bit ADC the denominator is 255. For 10 bit ADC, the denominator is 1023, (2¹⁰-1).

Those of you trying to make a line follower, if you are going to use ADC, you can use the circuit for the line sensor shown below. The line marked output is given as input to one of the ADC channels of the microcontroller.

In case of any doubt, or if you need help in doing a project using ADC, please leave a comment below.

Follow Techila on Facebook.

Projects: Line Follower

2011-04-29T09:26:00.001+05:30

Project: Line Follower
Author: Gaurav Upreti

If you are making the same project and wish to contact the author for help, please send a mail to blogger_engg@gmail.com with the subject line: Line_follow@gaurav_upreti.

Interfacing LCD

2011-04-28T15:10:00.003+05:30

LCD or Liquid Crystal Display is fast becoming a preferred choice for use as interface device for displaying over 7-Segment.

Every LCD needs a driver to interface between the microcontroller and LCD module. This driver is included on the LCD module.

The LCD we are using here is a 16x2 LCD. That means it has 16 columns and 2 rows.

Pin number 1 and 16 will be written behind the LCD.

The Pin Configuration of the LCD is given below

(open image in separate tab to expand)

The LCD uses three control lines, EN, RS and RW.

The EN line is called 'Enable'. This control line is used to tell the LCD that you are sending it data. To send the data to the LCD, your program should make sure this line is low (0) and then set the other two control lines and/or put data on the data bus. When the other lines are completely ready, bring EN high (1) and wait for the minimum amount of time required ( about 200ns), and end by bringing it low(0) again.

The RS line is the 'Register Select' line. When RS is low(0), the data is to be treated as a command or special instruction (such as clear screen, position cursor, etc.). When RS is high (1), the data being sent is text data which should be displayed on the screen. For example, to display the letter 'T' on the screen you would set RS high(1).

The RW line is the 'Read/Write' control line. When RW is low (0), the information on the data bus is being written to the LCD. When RW is high (1), the program is effectively querying (or reading) the LCD. All commands are write commands except for 1 ('Get LCD status'), which is a read command. Thus, RW will almost always be low.

4 bit Mode / 8 Bit mode:

The LCD can work in either 8 bit parallel mode, i.e, then entire 8 bit data can be sent at once, or it can be used in 4 bit mode. In 4 bit mode the 8 bit data is broken into packets of 4 bit data and sent (higher 4 bits first, then lower 4 bits). 4 bit mode simplifies the circuit.
Upon power on, the LCD is automatically in 8 bit mode.
Here, we are using the LCD in 4-bit mode.

Initializing the LCD

Before you may really use the LCD, you must initialize and configure it. This is accomplished by sending a number of initialization instructions to the LCD.

The first instruction we send must tell the LCD we'll be communicating with it with a 4-bit data bus (4-bit mode). We also need to select a 5x8 dot character font. These two options are selected by sending the command 20h ( 'h' denotes hexadecimal format) to the LCD as a command.
We've now sent the first byte of the initialization sequence. The second byte of the initialization sequence is the instruction 0Fh. This commmand is sent to instruct the the LCD to, 'Display on, Cursor Blinking'.
Other commands are also available. Send higher nibble first, then lower nibble.

This circuit diagram can be used as a reference.

You can download a header file for your use from here. The pin connections are mentioned in the header file.

For any further clarification please leave a comment below or mail us at blogger.engg@gmail.com

Starting WinAVR

2011-04-27T17:24:00.001+05:30

Setup of WinAVR can be downloaded from this link.

Once you are done installing, open the start menu and search for Programmer's Notepad. Click on it to open.

It should look something like this.

The bar on the left side may or may not be there.

The program is written in the large white area ( 'notepad' ).

The window at the bottom is called the output window.

The language in which the program is being written can be selected as shown.

Once the language has been selected, the program should be written in the notepad.

Once the program is written. Make a new folder and save this program with the extension .c. for example, main.c

For every program you write create a separate folder for it.

Once this is done, an mfile has to be created.

Search for 'mfile' in the start menu.

It'll look something like this.

After that, click on 'Makefile' and select 'Main File Name'.

A small window will open up. Write the name of the file you have saved. Don't write the extension of the file. For example, if the name of your file is main.c, write main in that window.

After that, in 'Makefile' select 'MCU type' and select the microcontroller you are using.

Then in 'Makefile' go to 'port' and select the port that is being used for programming. This depends on whether the programmer you are using. It may use a USB programmer or COM port or others. If you are not sure, contact the person you bought it from. If it is still not clear, please contact us at blogger.engg@gmail.com, or post your doubt as a comment below and we'll contact you.

After that select the programmer you are using.

Some programmer like USBASP are not mentioned in this. To select those programmers, select any programmer you want, then click on enable editing of makefile in 'Makefile' and in place of the text highlighted in yellow write the programmer you are using, in small letters (e.g usbasp)

Once you have selected enable editing of makefile, scroll up to find the text as shown in the picture below, and change the entry encircled below to the frequency of the crystal you are using.

After this go to 'File' in the mfile box only, and click 'Save As'. This file should be saved in the same folder that your .c file has been saved with the name 'Makefile'. If this name is already displayed, don't change it. This file should not be saved with any other name.

Go back to programmer's notepad, go to 'Tools', select 'Make All'. This creates the hex file ( this file will be present in the folder) which is required to program your microcontroller. Syntax or mfile related errors, if any, are shown in this step in the the output window.

Make sure that your programmer is connected, and then go to 'Tools' and select 'Program'.

That's it. Your microcontroller is programmed!

If you are not sure how to use your programmer, contact the person you bought it from. If it is still not clear, or you have any doubts in the above steps please contact us at blogger.engg@gmail.com, or post your doubt as a comment below and we'll contact you.

Using a switch with a Microcontroller

2011-04-25T13:12:00.002+05:30

, w

Suppose you want to use a switch with a microcontroller.

Please go through this article on ' Pull Ups and Pull Downs ' before starting.

We'll assume that the switch will give a 0 when it is pressed and that the switch is connected at PB.0 .

Thus, the pin of the Microcontroller at which the switch is connected will get a 0 when the switch is pressed.

If that pin is already at 0, in this case the microcontroller will not be able to detect that a switch is pressed as there will be no change on the status of the pin.

So, to positively detect a switch press at PB.0 we need to set it to 1, i.e pull-it-up.

Since, we have to check/detect/receive an input on PB.0, we need to make that as an input port, i.e

DDRB=0b00000000;

Since I am not using the other pins of PortB, it does not matter whether I write 1 or 0 to them. If the other pins are being used as output, then we should set PB.0 as input using the unary OR, denoted by ' | ', operator.

after DDRB, we need to give the PORT command,

PORTB=0b00000001; // make PB.0 as 1.

The following picture shows, what happens when we give a 1 to a pin, declared as output, to which LED are connected. Notice the intensity of the LED.

In the next picture we declared the pins connected to the LED as input and then set the pins to 1.

Notice the change in intensity?
In the case when the port is declared as input and we still try to give an output to it, a small amount of current is provided on those pins as compared to when the port has been declared as output.

Now, using the same logic in case of switches.
We'll declare the pin to which the switch is connected as input and give an output on it, so that a small current is provided on it. Thus, every time the switch is pressed, the pin receives a definite 0.

#include<avr/io.h>
#include<util/delay.h>
void main()
{
   DDRC=0b11111111; // assuming that LED's are connected at PortC.
   DDRB=0x00;
// making PB.0 as input (here, other pins will also become input, but since we // are not using them, it doesn't matter)

  PORTB=0b00000001; // give a 1 on PB.0 to provide a small current on it.

  while(1)
  { if(PINB==0b00000000) // 'PIN' is used for checking input
   { // when switch is pressed, entire port becomes 0
   PORTC=0xff; // we could also have written if(PINB==0)
   }
   else
   PORTC=0x00;
  }
}

In the above program, LED glow only when the switch is pressed.

Playing with LED

2011-04-24T18:47:00.003+05:30

In this post we'll make a scrolling pattern on the LED's (watch the video).

Just like last time, we'll consider that we have 8 LED's connected to PortC.

Now, the LED have to be turned ON, only one at a time, and they should remain ON for some time (say, 500 milliseconds).

#include<avr/io.h>

#include<util/delay.h> // header file for generating delay

void main()

{ DDRC=0b11111111; // Since, PortC is output, thus, all 8 bits are declared 1

PORTC=0x00; // initially all LED will be off.

Note: If on your development board, the LED are connected in Active Low configuration, they will turn ON when a '0' is given. If the LED are active high, they will turn ON when '1' is given. If you are not sure whether your LED are active high or active low, just give 1 and see what happens.

Here, I am assuming that LED are active high.

while(1) // infinite loop so that the process inside is executed all the time.

{

PORTC=0b00000001;

_delay_ms(500);

PORTC=0b00000010;

_delay_ms(500);

PORTC=0b00000100;

_delay_ms(500);

PORTC=0b00001000;

_delay_ms(500);

PORTC=0b00010000;

_delay_ms(500);

PORTC=0b00100000;

_delay_ms(500);

PORTC=0b01000000;

_delay_ms(500);

PORTC=0b10000000;

_delay_ms(500);

}

In the above program, we make only one LED on at a time, give a delay, and then turn on the next LED and switch off the other LED by writing 1 to the LED which we want to turn ON and the rest are 0.

The above program, though simple, is cumbersome to write.

We'll write the above program in a different way utilizing the vast potential of C.

#include<avr/io.h>

#include<util/delay.h>

volatile unsigned char x=0;

void main()

{

DDRC=0b11111111; // Declare entire PortC as output

PORTC=0b00000000; // Make PortC initially 0.

while(1)

{ x=0;

while(x<8) // execute this part till x is less than 8

{ PORTC=(1<<x); // shift 1 by 'x' spaces.

_delay_ms(500);

x=x+1; // increment x.

}

We would like to point out one very important thing about Embedded C at this point.
Notice the 'volatile unsigned char x=0' before the main() ?
In embedded C, all variables that are to be used should be defined and initialized before the main() starts.

Our First Program

2011-04-03T11:07:00.007+05:30

Let's write a program to simply turn on LED's.

We will use the Programmer's Notepad of WinAVR.
WinAVR can be downloaded from this link.
Once WinAVR is installed, open Programmer's Notepad and start typing. Save the file with a .c extension. example, led.c .
We will assume that we have 8 LED's, connected to the 8 pins of Port C.

Step 1: Declare the Ports to be used as output or input (as required).

In this case the LED’s connected to Port C have to be turned ON, i.e a current has to be supplied to the LED. Thus, Port C should be OUTPUT.

Thus, the Data Direction Register for Port C is

thus, we can write

DDRC=0b1111111;

This statement makes the PortC output port. Since, we need only PortC in this particular case, we are not going to specify for other Ports.

Step 2: Turn ON the LED

Now, to turn on the LED's, we need to give a '1' to the Port.

thus,

PORTC=0b11111111;

Thus, the program can be written like this:

#include<avr/io.h> // standard library to be included when using WinAVR

void main()

{

DDRC=0b11111111; // Declare PortC as output Port

PORTC=0b11111111;

}

This program will turn on the LED's connected to PortC.

Here we have considered 8 LED's. If, let's say 3 LED's were connected to PC0, PC1, PC2, then only these 3 pins need to be written '1', the rest can be '0' or '1' (if they are not being used anywhere else)

thus,

DDRC=0b00000111;

PORTC=0b00000111;

Once you have installed WinAVR, in the libraries folder, there will be a folder 'util' which will contain a file 'delay.h'. This file contains pre-defined functions to generate delays of the order of milli-seconds and micro-seconds.

Let's modify the program by turning the LED's ON and OFF with a delay of 500 milli-seconds.

#include<avr/io.h>
#include<util/delay.h> // include this header file to use the functions defined
// for generating a delay
void main()
{
DDRC=0b11111111; // Declare PortC as output Port

  PORTC=0b11111111; // Give a '1' to all the pins of PortC thus turning ON the LED's
while(1) // this is an infinite loop.
{  PORTC=0b11111111; // Give a '1' to all the pins of PortC thus turning ON the LED's
   _delay_ms(500); // hold the LED ON for 500 millisecond

   PORTC=0b00000000; // Turn OFF all the LED's
   _delay_ms(500); // hold the LED OFF for 500 millisecond
  }
}

The function _delay_ms(x) generates a delay of x milli-seconds.
The above program will blink the LED's.
We used an infinite loop in the above program because we wanted the LED's to continue blinking forever. Had we not written the part for blinking the LED's inside the infinite loop, the LED's would have blinked just once.

In the video above, only 4 LED are blinking.

In the next post we will again play around with the LED's, generating some new patterns and probably some 'disco LED' :D

Pull Ups and Pull Downs

2011-02-19T20:33:00.001+05:30

Pull up and Pull Down.

Pull up and Pull down is a very simple concept.
Let's try to understand it through an example.

Take the case of a simple NOT gate. It simply negates the input.

Input	Output
0	1
1	0

But, What would appear at the output if the input is left unconnected? Will it be a Logic 0 or a Logic 1?
You might say that since there is no connection at the input, the voltage at the input pin would be Logic 0 and hence the output of the NOT gate shall be high.
But, have any of you ever observed an output from a not gate without any input?.

When nothing is connected to the input pin, the pin isn’t at zero volts but its “floating”. (In electronics, an unconnected input pin is termed as floating) In the digital world, particularly TTL, any floating input is considered as Logic 1. But it’s never a good idea to leave the input pins unconnected. Why? Well, that’s because noise generated by adjacent electrical activity can induce a significant amount of voltage across the input which could result in errant behavior of the system.

Hence, its always advisable to have a default value at the inputs. This can be achieved by connecting pull-up or pull-down resistors at the inputs.

The same logic applies while interfacing devices to the microcontroller. Most of the microcontrollers available have inbuilt pull-up resistors which can be enabled or disabled through software. These prove to be very handy while connecting external devices, say for example a switch. But, when internal pull-ups are not available, we need to connect external pull-ups. Pull-downs can also be connected, but we need to make sure that there are no internal pull-ups activated on that particular port.

In the figure above, the switch is connected in an active-low configuration. Which means whenever you press the switch, logic 0 appears at the input. Thus, the code will be written accordingly.

eg:

if (switch==0)
{
//switch pressed
}

else //switch open

There are no specific values for such pull-ups or pull-downs; they could be anywhere between 1K and 47K.

( source: ThinkLabs Technosolutions)

Set Operation

2011-02-13T20:46:00.000+05:30

Setting a bit in a Register:

In Embedded C, binary numbers are represented with a '0b' prefix. To represent a hexadecimal number, put a '0x' instead of '0b'. Decimal numbers can be written directly, they don't need any prefixes.

Let us consider an 8 bit register, ADMUX. And our aim is to assign the 5th bit (the right most bit is the 1st bit) a value of logical 1. The syntax will be

ADMUX=0b00010000;

When the above statement is processed, the 5th bit will be set to 1, and the rest set to logical 0.

Now, if we want to set the 1st bit also 1, without changing the status of the 5th bit,

ADMUX=0b00010001;

Suppose the above line is the 1st line of our program, if we want to change the value of the 3rd bit of this register ADMUX, without changing the value of any other bit, we will have to retrace it back through our code, which will be very cumbersome. Hence, we use | (OR) bit wise operator. It performs bitwise OR.

Example: 0b11001101 | 0b00000010

1 1 0 0 1 1 0 1

OR 0 0 0 0 0 0 1 0

Result: 1 1 0 0 1 1 1 0

As we can see, in the 2nd number only the 2nd bit from the right was set to 1. When bitwise OR operation was performed of this number with 11001101, the result obtained was same as the first number except for the 2nd bit, which had changed to 1. Thus, the bit had been SET.

Hence, for Setting a particular bit of a register, without disturbing the contents of the other bits, we perform bitwise OR operation ( | ) of the register with a binary number which has a 1 at the position of the bit we want to set in the register.

e.g: ADMUX= ADMUX | (0b00001000);

This can also be written as

ADMUX|=(0b00001000);

In practice, each bit has got a name according to the function it performs. Let's say the 5th bit has got a name ADEN (ADC Enable), it is used to enable the ADC. When it is set to 1, the ADC function of the microcontroller is enabled. When it is 0 it is disabled.

If we employ the syntax explained above, we will have to check the datasheet all the time to verify the position of ADEN. The following syntax circumvents that,

ADEN|=(1<<ADEN);

The << is called the left shift operator. It shifts the bits of the variable on its left hand side by the number of places specified by the number on its right hand side.

If we write.

A=1<<4;

then, 1, whose binary value is 00000001 is shifted 3 places to the left. The result is 00001000.

So, if ADEN is the 5th bit,

ADMUX|=(1<<ADEN);

will result in

ADMUX|=(1<<5);

which will result in

ADMUX|=(0b00100000);

What is this better? Why should I prefer this method?

This is why this method is much better:

Readability of code: ADMUX|=(1<<ADEN); tells you what bit is being set. It tells you that here the ADC is being enabled. ADEN=5 is already defined in the header file of that microcontroller.

Portable: Let's say that you use this code is really useful and has been used several times in a very long program. You need this code to run on another microcontroller. This other microcontroller belongs to the same family as your old one, but the positions of the bits (bit scheme) is slightly different, i.e ADEN may be at bit 2 instead of 5. You'll have to find all occurences of ADMUX|=(0b00010000); and change them to ADMUX|=0b00000010; But, if you have used the other method you dont have to make any changes in your code as the position of ADEN would have been specified in the header file for that particular microcontroller.

Binary Numbers

2011-02-13T00:24:00.000+05:30

While programming Microcontrollers in C, most of the time we have to deal with registers. We may have to 'SET' the bits of a register, 'CLEAR' the bits of a register or 'CHECK' the status of a particular bit of a register. Before we do all this, let us first take a look at binary numbers and conversion to decimal number system.

A register is simply a collection of some bits.
When you pick up a microcontroller's datasheet, it'll say that, that particular microcontroller is a '8 bit Microcontroller' or '4 bit microcontroller' etc. It means that the register is 8 bits or 4 bits long respectively.
Now, each bit of this register can hold either a '0' (zero) or '1' (one).

Let's consider a variable 'A' which has a binary value 1101 (read as, one one zero one).
To convert A to decimal form, follow the following steps:

Assign precedence values 0,1,2,3..and so on, to each binary bit starting from the right most bit.
Thus in the case of A:

Now, multiply each bit with 2^precedence value. Then add up all the results.

Therefore, A (in decimal form) = 1x2³ + 1x2² + 0x2¹ + 1x2⁰ = 1x8 + 1x4 + 0x2 + 1x1 = 8+4+0+1=13

Thus, decimal form of 1101 is 13.

Here, A was a 4 bit register.

Now, consider A to be an 8 bit register. The maximum binary value possible for A=11111111.

Assigning precedence values to A

Using the same method again, we get A (in decimal form)= 255. Thus, the maximum value of an 8 bit register is 255.

Binary Numbers in C:

When you write A=101, in a C program, the compiler will interpret it as one hundred and one, which is a decimal number. To specify that a number is binary, we need to prefix a '0b' before that number.
The statement,

A=0b11001101;

implies that A stores a binary value 11001101 (one one zero zero one one zero one). The bit pattern 11001101 is assigned to A. Here, A is assumed to be a 8 but register. If A were a 4 bit register, then only the first 4 bits, from the right would be stored and the rest would be neglected.

DDR, PORT, PIN

2011-02-01T07:29:00.002+05:30

The contents of DDR decide whether a particular pin of the microcontroller acts as an INPUT pin, that is, it’ll be used to get an input from the outside world, or as an output, that is, it’ll be used to give an output to the outside world.

For DDR register,

1 --> Output

0 --> Input

If I set a particular bit of the DDR register as 1, it means that the pin number, corresponding to that bit number will work as an output pin. If a bit is made 0, the pin number corresponding to that particular bit will act as in input.

Please note that pin number and bit number count starts from 0. That means, PA0 is the 1st pin and PA7 is the 8th pin.

Let’s say we want the 3rd pin ( that means, PA2) of Port A to function as an output pin. This is what the DDRA register will look like

Thus, while writing the program in WinAVR, we can simply write the statement as

DDRA=0x80; // this statement will make PA2 an output pin

Similarly, PORTA is used for assigning a HIGH (1) or a LOW (0) signal to an output pin.

When we want to check whether an input pin is receiving a HIGH (1) or a LOW (0) we use PIN.

Getting Used to AVR

2011-01-31T23:17:00.000+05:30

Getting used to AVR

Datasheet. A datasheet is a document provided by the manufacturer of an IC that gives information about various Pins of those IC’s and their function.

To learn AVR Microcontrollers, it is necessary to have that particular Microcontroller’s Datasheet with you. The datasheets are available for free on the Internet.

Our programming platform shall be WinAVR, which is also a free software available on the internet.

The best way to learn using a microcontroller, for a newbie, is using a development board. You could either make one on your own or buy them online. It’s best to buy one, it reduces the errors that might arise out of incorrect hardware connections. So, if you are looking to buy a development board, you can buy them from robokits.co.in, thinklabs.in...there are many other websites too. There are different types of programmers available. Please make sure that you know which programmer is used to program your board. It may be different for different boards.

The 1st thing that you need to be familiar with is a microcontroller’s Inputs and Outputs.

We will be considering Atmega16 throughout the course of this series. The PIN DIAGRAM of Atmega16 and Atmega32 are identical.

(click on the photo to enlarge it)

As can be seen the pins for both the IC’s are identical. The only major difference is that ATmega16 has 16K Bytes of In-System programmable flash memory while an ATmega32 has 32K Bytes of flash memory.

ATmega16 (and ATmega32) has a total of 40 pins, of which 32 can be used as Input or output. These pins are divided into 7 ports

PORTA- 8 pins ( PA0 to PA7)

PORTB- 8 pins ( PB0 to PB7)

PORTC- 8 pins ( PC0 to PC7)

PORTD- 8 pins ( PD0 to PD7)

Each of these ports is associated with 3 registers: DDRx, PORTx, PINx, where ‘x’ stands for the port name (A,B,C or D). e.g DDRA, PORTA, PINA etc.

NOTE: While programming, DDRx,PORTx,PINx are always written in capitals.

DDR stands for Data Direction Register. It decides whether a particular pin will act as input or output.

(please note that PIN refers to the register and pin refers to some pin of the microcontroller)

Since a Port has 8 pins, all the registers, DDR,PORT,PIN are 8 bit register. Each bit corresponds to a pin of that particular port. Consider the example of port A

(click on the photo to enlarge it)

MSB stands for Most Significant Bit. LSB stands for Least Significant Bit.

Embedded Systems

2011-01-31T21:09:00.000+05:30

Embedded System. The term itself brings to mind some chip ‘embedded’ on a surface with complex wiring connections further connecting it to some even more complex ‘embedded’ systems.

Well, they are actually a lot simpler.

In simple words and Embedded System is any electronic system that uses a ‘chip’.

Microcontrollers and Microprocessors are two of the most common and most used embedded systems.

A microprocessor is a general purpose chip used in applications which require huge amount arithmetic, logical etc. operations. Our laptops use a microprocessor chip.

A microcontroller on the other hand is designed for specific tasks. Unlike a microprocessor it cannot be designed for controlling several processes. A microcontroller is preferred in applications that do not require too many tasks to be performed. If you guys ever open up your washing machines, you might find a microcontroller chip inside it. All those functions that a washing machine performs, toggle, spin, dry.. are controlled by a microcontroller.

A microcontroller is much cheaper than a microprocessor. It requires much less power. For this reason, they are the favoured option for most robotic applications.

Microcontrollers are, for us robo-tists, a godsend. They showed us how we can make interesting projects in the seemingly dull course structure. They give us the first glimpse of what it is like to be an engineer.

Microcontrollers are easily available in the market. They belong to different families aka companies.

8051: the ‘8051 core’ was the de-facto standard in 8-bit (and 4-bit) microcontrollers. Developed by Intel in the 1980’s, it still seems to be the instruction set they love to teach you in college. They are based on VERY OLD, but field proven instruction set. Very old techs, in my humble opinion, but these IC’s have been significantly improved.
PIC: This is the classic microcontroller from Microchip. Very simple, very proven, but it lacks some features that other manufacturer’s are building into their chips.
AVR: This is a direct competitor of PIC. Designed and named AVR for god knows what reason by Atmel, it is a direct competitor of PIC. It does everything a PIC does, only faster and cheaper. The AVR series of Microcontrollers are readily available in the market. Also, their platform for programming is not licensed, but freely available on the web.
MSP: These microcontrollers by Texas Instruments are pretty good, but, they truly excel at low power applications. Imagine running a complete system on one AA battery for 5 years. This is the realm of nano-amp current consumption.
ARM: Dunno what ‘ARM’ stands for. But, these are VERY powerful, extremely low power consumption and very low cost. But, for a beginner they can get really intimidating if you haven’t played around with a Microcontroller before.

The most popular microcontroller among robot-enthusiasts, for now, is Atmel’s AVR. In the coming weeks we shall be covering various topics on ‘How to Program a Microcontroller’.

If you are interested in learning how to program and use a microcontroller, it’s best to buy a development board. Because, you see, it reduces the number of errors possible in the system. If you are using a development board, the only errors that will be present will be the ones you make in programming, which can be easily rectified. But, once you have mastered the skill of programming a microcontroller, go for designing the hardware of your Microcontroller system ( not the microcontroller, you can use the chip in your system :P ) on your own.

Voltage Regulator IC 7805

2011-01-31T20:03:00.001+05:30

Voltage Regulator IC 7805

Let's say you want to play with your Microcontroller today.

With any IC, you need to power the thing.

There are two power connections on basic micros : VCC and GND. What the heck is VCC? This is the label for the positive voltage. Don't worry, after a few days of this, seeing 'VCC' will become very normal. GND is short for ground. All electrical current needs a way to flow back to ground. This can be called 'common' but is often just labeled GND.

There are thousands of different micros out there, but 5V (five volts) is the typical VCC. 3.3V is also typical but you'll also see 2.8V and 1.8V VCCs on more exotic micros. For now, just worry about 5V and GND.

Where do I find this 5V?

You need to hook up 5V and GND to your micro.

Quick note: If you reverse the connection on your micro - bad things happen. Always make sure your 5V power supply is connected to the VCC pins and GND to GND. If you reverse this and connect 5V to GND on the micro and GND to VCC on the micro, things won't explode, probably no smoke, but things will probably heat up like crazy, and you'll probably damage your 250 bucks micro. You probably will. I did. Many times. Try not to do it.

Ok! You need 5V. Time to build a simple voltage regulator circuit!

The most common regulator is called the LM7805. Why? I dunno. I've never actually touched a component with LM7805 stamped on the outside. There's always other letters stamped on the outside like 'LM78X05' or 'LV78X05' or some such crazyiness. Just know that there are many many manufacturers out there and they are all producing the same basic part, with small tweaks to each one. What you need is one of these generic parts that is designated as a '5V linear regulator'.

LM7805

Here you can see the 'pin-out' of the LM7805. Say 'IGO' in your head and commit this to memory (input, ground, output). You'll probably hook up a lot of these. When in doubt, always check the datasheet before hooking up a new part - or else be close to the on/off switch! Input is the input voltage of anything greater than about 7V. GND is ground. Output is the 5V output pin. All grounds need to be connected together for current to flow across the system. One more time - connect all grounds. This is the main reason why a novii can't get a system to work.

Schematic

Schematic note: The two ground pins are not shown connected. We assume that nets (the green wires) of the same name are connected together. Schematics can get big and complex, so you won't see all the wires together, but in your breadboard you need to connect all the GND pins together. In this case it's the GND wire from your 9V battery (power source) connected to the GND pin on the regulator.

Now, just wire it all up on a breadboard.

Congratulations! You've built up your very first voltage regulator! Now leave this 5V power supply wired in your breadboard! You are going to use it many times...