[attachment=3083]
[attachment=3084]

LINE FOLLOWING ROBOT

Introduction

What is a line follower?
Line follower is a machine that can follow a path. The path can be visible like a black line on a white surface (or vice-versa) or it can be invisible like a magnetic field.
Why build a line follower?
Sensing a line and maneuvering the robot to stay on course, while constantly correcting wrong moves using feedback mechanism forms a simple yet effective closed loop system. As a programmer you get an opportunity to Ëœteachâ„¢ the robot how to follow the line thus giving it a human-like property of responding to stimuli. Practical applications of a line follower : Automated cars running on roads with embedded magnets; guidance system for industrial robots moving on shop floor etc.

Prerequisites:
Knowledge of basic digital and analog electronics. (A course on Digital Design and Electronic Devices & Circuits would be helpful) C Programming Sheer interest, an innovative brain and perseverance!

Background:
I started with building a parallel port based robot which could be controlled manually by a keyboard. On the robot side was an arrangement of relays connected to parallel port pins via opto-couplers. The next version was a true computer controlled line follower. It had sensors connected to the status pins of the parallel port. A program running on the computer polled the status register of the parallel port hundreds of times every second and sent control signals accordingly through the data pins. The drawbacks of using a personal computer were soon clear “ It™s difficult to control speed of motors As cable length increases signal strength decreases and latency increases. A long multi core cable for parallel data transfer is expensive. The robot is not portable if you use a desktop PC. The obvious next step was to build an onboard control circuit; the options “ a hardwired logic circuit or a uC. Since I had no knowledge of uC at that time, I implemented a hardwired logic circuit using multiplexers. It basically mapped input from four sensors to four outputs for the motor driver according to a truth table. Though it worked fine, it could show no intelligence “ like coming back on line after losing it, or doing something special when say the line ended. To get around this problem and add some cool features, using a microcontroller was the best option.
The AVR microcontroller:
Atmel's AVR® microcontrollers have a RISC core running single cycle instructions and a well-defined I/O structure that limits the need for external components. Internal oscillators, timers, UART, SPI, pull-up resistors, pulse width modulation, ADC, analog comparator and watch-dog timers are some of the features you will find in AVR devices.
AVR instructions are tuned to decrease the size of the program whether the code is written in C or Assembly. With on-chip in-system programmable Flash and EEPROM, the AVR is a perfect choice in order to optimize cost and get product to the market quickly. -http://atmelproducts/avr/ Apart form this almost all AVRs support In System Programming (ISP) i.e. you can reprogram it without removing it from the circuit. This comes very handy when prototyping a design or upgrading a built-up system. Also the programmer used for ISP is easier to build compared to the parallel programmer required for many old uCs. Most AVR chips also support Boot Loaders which take the idea of In System Programming to a new level. Features like I2C bus interface make adding external devices a cakewalk. While most popular uCs require at least a few external components like crystal, caps and pull-up resistors, with AVR the number can be as low as zero! Cost: AVR = PIC > 8051 (by 8051 I mean the 8051 family) Availability: AVR = PIC <8051 Speed: AVR > PIC > 8051
Built-in Peripherals: This one is difficult to answer since all uC families offer comparable features in their different chips. For a just comparison, I would rather say that for a given price AVR = PIC > 8051.
Tools and Resources: 8051 has been around from many years now, consequently there are more tools available for working with it. Being a part of many engineering courses, there is a huge communitiy of people that can help you out with 8051; same with books and online resources. In spite of being new the AVR has a neat tool chain (See ˜References and Resources˜). Availability of online resources and books is fast increasing. Here, 8051 > AVR = PIC.
Overview

Block Diagram
The robot uses IR sensors to sense the line, an array of 8 IR LEDs (Tx) and sensors (Rx), facing
the ground has been used in this setup. The output of the sensors is an analog signal which
depends on the amount of light reflected back, this analog signal is given to the comparator to
produce 0s and 1s which are then fed to the uC.
L4 L3 L2 L1 R1 R2 R3 R4
Left Center Right
Sensor Array
Starting from the center, the sensors on the left are named L1, L2, L3, L4 and those on the right
are named R1, R2, R3, R4.
Let us assume that when a sensor is on the line it reads 0 and when it is off the line it reads 1
The uC decides the next move according to the algorithm given below which tries to position the
robot such that L1 and R1 both read 0 and the rest read 1.
L4 L3 L2 L1 R1 R2 R3 R4
1 1 1 0 0 1 1 1
Left Center Right
Desired State L1=R1=0, and Rest=1
Algorithm:
1. L= leftmost sensor which reads 0; R= rightmost sensor which reads 0.
If no sensor on Left (or Right) is 0 then L (or R) equals 0;
Ex:
Left Center Right
Here L=3 R=0
Left Center Right
Here L=2 R=4
2. If all sensors read 1 go to step 3,
else,
If L>R Move Left
If L<R Move Right
If L=R Move Forward
Goto step 4
3. Move Clockwise if line was last seen on Right
Move Counter Clockwise if line was last seen on Left
Repeat step 3 till line is found.
4. Goto step 1.
L4 L3 L2 L1 R1 R2 R3 R4
1 0 0 1 1 1 1 1
L4 L3 L2 L1 R1 R2 R3 R4
1 1 0 0 0 0 0 0

Implementation
Sensor Circuit:


To get a good voltage swing , the value of R1 must be carefully chosen. If Rsensor = a when no light falls on it and Rsensor = b when light falls on it. The difference in the two potentials is:
Vcc * { a/(a+R1) - b/(b+R1) }
Relative voltage swing = Actual Voltage Swing / Vcc
= Vcc * { a/(a+R1) - b/(b+R1) } / Vcc
= a/(a+R1) - b/(b+R1)
The resistance of the sensor decreases when IR light falls on it. A good sensor will have near zero resistance
in presence of light and a very large resistance in absence of light. We have used this property of the sensor to form a potential divider. The potential at point ˜2™ is Rsensor / (Rsensor + R1). Again, a good sensor circuit should give maximum change in potential at point ˜2™ for no-light and bright-light conditions. This is especially important if you plan to use an ADC in place of the comparator
To get a good voltage swing , the value of R1 must be carefully chosen. If Rsensor = a when no light falls on it and Rsensor = b when light falls on it. The difference in the two potentials is:
Vcc * { a/(a+R1) - b/(b+R1) }

Relative voltage swing = Actual Voltage Swing / Vcc
= Vcc * { a/(a+R1) - b/(b+R1) } / Vcc
= a/(a+R1) - b/(b+R1)


The sensor I used had a = 930 K and b = 36 K. If we plot a curve of the voltage swing over a range of values of R1 we can see that the maximum swing is obtained at R1= 150 K (use calculus for an accurate value). There is a catch though, with such high resistance, the current is very small and hence susceptible to be distorted by noise. The solution is to strike a balance between sensitivity and noise immunity. I chose value of R1 as 60 K. Your choice would depend on the Ëœaâ„¢ and Ëœbâ„¢ values of your sensor. If you found this part confusing, use a 10K resistor straightaway, as long as you are using a comparator it wonâ„¢t matter much.
Motor Interface and Control Circuit:

The 8 sensors are connected to PORTA.
You need not connect anything to AVCC and AREF, it is required only if ADC is used. The L298 Motor Driver has 4 inputs to control the motion of the motors and two enable inputs which are used for switching the motors on and off. To control the speed of the motors a PWM waveform with variable duty cycle is applied to the enable pins. Rapidly switching the voltage between Vs and GND gives an effective voltage between Vs and GND whose value depends on the duty cycle of PWM. 100% duty cycle corresponds to voltage equal to Vs, 50 % corresponds to 0.5Vs and so on. The 1N4004 diodes are used to prevent back EMF of the motors from disturbing the remaining circuit. Many circuits use L293D for motor control, I chose L298 as it has current capacity of 2A per channel @ 45V compared to 0.6 A @ 36 V of a L293D. L293Dâ„¢s package is not suitable for attaching a good heat sink, practically you canâ„¢t use it above 16V without frying it. L298 on the other hand works happily at 16V without a heat sink, though it is always better to use one.



Source Code
/*****************************************************
Project : Line Follower
Version :
Date : 2/19/2006
Author : Priyank
Company : Home
Comments:
Chip type : ATmega16
Program type : Application
Clock frequency : 7.372800 MHz
Memory model : Small
External SRAM size : 0
Data Stack size : 256
*****************************************************/
//#define debug 1
#include <mega16.h>
#include <delay.h>
#ifdef debug
#include <stdio.h>
#endif
#define FWD 0xAA
#define REV 0x55
#define R 0x22
#define L 0x88
#define CW 0x99
#define CCW 0x66
#define STOP 0x00
#define B 0xFF
#define RSPEED OCR1AL
#define LSPEED OCR1BL
#define SPEED0 255
#define SPEED1 0
#define SPEED2 0
#define SPEED3 0
#define MAX 3
#define HMAX 1
void move (unsigned char dir,unsigned char delay,unsigned char power);
unsigned char i,rdev,ldev,ip,delay,dir,power,dirl,history[MAX],hcount=0,rotpow;
#ifdef debug
unsigned char rep=0,prev=0;
#endif
void main(void)
{
// Input/Output Ports initialization
// Port A initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTA=0x00;
DDRA=0x00;
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTB=0x00;
DDRB=0x00;
// Port C initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTC=0x00;
DDRC=0xFF;
// Port D initialization
// Func7=In Func6=In Func5=Out Func4=Out Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=0 State4=0 State3=T State2=T State1=T State0=T
PORTD=0x00;
DDRD=0x30;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 921.600 kHz
// Mode: Fast PWM top=00FFh
// OC1A output: Non-Inv.
// OC1B output: Non-Inv.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0xA1;
TCCR1B=0x0A;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0xFF;
OCR1BH=0x00;
OCR1BL=0xFF;
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// INT2: Off
MCUCR=0x00;
MCUCSR=0x00;
#ifdef debug
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 57600
UCSRA=0x00;
UCSRB=0x18;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x07;
#endif
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
while (1){
#ifdef debug
if(rep<255)
rep++;
if(prev!=PINA) {
prev=PINA;
printf("%u\r",rep);
for(i=0;i<8;i++)
printf("%u\t",(prev>>i)&0x01);
rep=0;
}
#endif
if(PINA!=255){
rotpow=255;
ldev=rdev=0;
if(PINA.3==0)
rdev=1;
if(PINA.2==0)
rdev=2;
if(PINA.1==0)
rdev=3;
if(PINA.0==0)
rdev=4;
if(PINA.4==0)
ldev=1;
if(PINA.5==0)
ldev=2;
if(PINA.6==0)
ldev=3;
if(PINA.7==0)
ldev=4;
if(rdev>ldev)
move(R,0,195+12*rdev);
if(rdev<ldev)
move(L,0,195+12*ldev);
if(rdev==ldev)
move(FWD,0,200);
}
else {
for(i=0,dirl=0;i<MAX;i++) {
if(history[i]==L)
{dirl++;}
}
if(rotpow<160) {rotpow=160;}
if(rotpow<255) {rotpow++;}
if(dirl>HMAX)
{move(CW,0,rotpow);}
else
{move(CCW,0,rotpow);}
}
};
}
void move (unsigned char dir,unsigned char delay,unsigned char power) {
PORTC=dir;
if(dir==L || dir==R) {
hcount=(hcount+1)%MAX;
history[hcount]=dir;
}
LSPEED=RSPEED=255;//power;
//delay_ms(delay);
}

Possible Improvements:
-Use of differential steering with gradual change in wheel speeds.
-Use of Hysteresis in sensor circuit using LM339
-Use of ADC so that the exact position of the line can be interpolated
-Use of Wheel Chair or three wheel drive to reduce traction.
-General improvements like using a low dropout voltage regulator, lighter chassis etc
References and Resources
Books:
Programming and Customizing the AVR Microcontroller “ Dhananjay V. Gadre
Parallel Port Complete “ Jan Axelson
Links:
Atmel Corp.
Makers of the AVR microcontroller
http://atmel.com
AVRbeginners.net
http://avrbeginners
AVR assembler tutorial
Tutorial for learning assembly language for the AVR-Single-Chip-Processors
AT90Sxxxx from ATMEL with practical examples.
http://avr-asm-tutorial
One of the best sites AVR sites
http://avrfreaks.net
WinAVR
An open source C compiler for AVR
http://sourceforgeprojects/winavr
PonyProg
A widely used programmer. Support for newer chips is added periodically. Can also
program PICs and EEPROMS
http://lancosprog.html
Basic Electronics
http://kpsec.freeuk
Williamson Labs
Nice animated tutorials, articles and project ideas.
http://williamson-labshome.htm
Small Robot Sensors
http://andrew.cmu.edu/user/rjg/websensor...sors2.html
Robotics India
An Indian site devoted to robotics. Must see
http://roboticsindia
Seattle Robotics Society
http://seattlerobotics
Line Follower ROBOT
Award winner from VingPeaw Competition 2543, the robot built with 2051, L293D, and
four IR sensors. Simple circuit and platform, quick tracking and
Easy to understand program using C language.
http://kmitl.ac.th/~kswichit/LFrobot/LFrobot.htm
Tools: AVR Studio
For writing code in assembly and simulation of code. Current versions has AVR-GCC
plug-in to write code in C.
Compilers: IAR, Image Craft , Code Vision AVR, WinAVR
Programmers: Pony Prog, AVR Dude, AVRISP and many more.
Evaluation Boards: STK200, STK500 from Kanda Systems

This article is presented by:
Priyank Patil
Department of Information Technology
K. J. Somaiya College of Engineering
Mumbai, India

INTRODUCTION

What is a line follower?
Line follower is a machine that can follow a path. The path can be visible like a black line on a white surface (or vice-versa) or it can be invisible like a magnetic field.
Why build a line follower?

Sensing a line and maneuvering the robot to stay on course, while constantly correcting wrong moves using feedback mechanism forms a simple yet effective closed loop system. As a programmer you get an opportunity to ‘teach’ the robot how to follow the line thus giving it a human-like property of responding to stimuli. Practical applications of a line follower : Automated cars running on roads with embedded magnets; guidance system for industrial robots moving on shop floor etc.
Prerequisites:

Knowledge of basic digital and analog electronics. (A course on Digital Design and Electronic Devices & Circuits would be helpful) C Programming Sheer interest, an innovative brain and perseverance!
Background:
I started with building a parallel port based robot which could be controlled manually by a keyboard. On the robot side was an arrangement of relays connected to parallel port pins via opto-couplers. The next version was a true computer controlled line follower. It had sensors connected to the status pins of the parallel port. A program running on the computer polled the status register of the parallel port hundreds of times every second and sent control signals accordingly through the data pins. The drawbacks of using a personal computer were soon clear – It’s difficult to control speed of motors As cable length increases signal strength decreases and latency increases. A long multi core cable for parallel data transfer is expensive. The robot is not portable if you use a desktop PC. The obvious next step was to build an onboard control circuit; the options – a hardwired logic circuit or a uC. Since I had no knowledge of uC at that time, I implemented a hardwired logic circuit using multiplexers. It basically mapped input from four sensors to four outputs for the motor driver according to a truth table. Though it worked fine, it could show no intelligence – like coming back on line after losing it, or doing something special when say the line ended. To get around this problem and add some cool features, using a microcontroller was the best option.

For more information about this article,plese follow the link:
http://googleurl?sa=t&source=web&cd=1&ve...llower.pdf&ei=SI60TMeKGoXevQOXuq2FCg&usg=AFQjCNG5jgcu5nWH5agjY6cZ6J0D6eMuAA

---

BY
AMITHASH E. PRASAD



What is a robot?
Robots are machines which do a task which would otherwise be done by human labor.
Robots may or may not possesses intelligence.


REQUIREMENT OF THE LFR
The robot must be capable of following a line.
It should be capable of taking various degrees of turns
It must be prepared of a situation that it runs into a territory which has no line to follow. (Barren land syndrome)
The robot must also be capable of following a line even if it has breaks.
The robot must be insensitive to environmental factors such as lighting and noise.
It must allow calibration of the line’s darkness threshold.
Scalability must be a primary concern in the design.
The color of the line must not be a factor as long as it is darker than the surroundings.

for more:
http://docs.googleviewer?a=v&q=cache:h3L...VabEMF_tCw

---

---

[attachment=8099]

Submitted by:-
Pankaj Kumar
Ashutosh Singh
Sameer Kumar
Gaurav kumar
Bhagwan thakur


INTRODUCTION:-
This simple robot is designed to be able to follow a black line on the ground without getting off the line too much. The robot has two sensors installed underneath the front part of the body, and two DC motors drive wheels moving forward. A circuit inside takes an input signal from two sensors and controls the speed of wheels’ rotation. The control is done in such a way that when a sensor senses a black line, the motor slows down or even stops. Then the difference of rotation speed makes it possible to make turns. For instance, in the figure on the right, if the sensor somehow senses a black line, the wheel on that side slows down and the robot will make a right turn.

THEORY OF OPERATION:-
How to sense a black line The sensors used for the project are Reflective Object Sensors, 0PB710F that are already ready in the Electronic Lab. The single sensor consists of an infrared emitting diode and a NPN Darlington phototransistor. When a light emitted from the diode is reflected off an object and back into the phototransistor, output current is produced, depending on the amount of infrared light, which triggers the base current of the phototransistor. In my case, the amount of light reflected off a black line is much less than that of a white background, so we can detect the black line somehow by measuring the current. (This current is converted to voltage.)

ii) How to control a DC motor
Instead of applying a constant voltage across a DC motor, we repeat switching on and off the motor with a fixed voltage (Vcc) applied to the motor. This is done by sending a train of PWM (Pulse Width Modulation) pulses to a power MOSFET in order to turn it on and off. Then, the motor sees the average voltage while it depends on duty cycle of PWM pulses. The speed of rotation is proportion to this average voltage.
By PWM method, it’s easier to control the DC motor than by directly controlling the voltage across it. All we have to do is to modulate pulse width, in ord


CONCLUSION:-
For a test, I held my robot in the air and I approached a white paper to sensors. Then, both wheels rotated as expected and they slowed down when either the paper moved away or sensors passed across a black line. Next, I put it down on the track, but unfortunately, it didn’t move. I found the torque of motors not enough to drive my robot. Even though the chosen DC motor was slowest and gave highest torque among other DC motors in the lab, it wasn’t enough. For solving this problem, I will have to find a suitable DC motor with large torque.
Overall, the robot project wasn’t successful, but it was quite a fun to go through all the process. I also realized that there were many things to consider practically such as installation of motors, building up a circuit by soldering and putting all parts together. This experience hopefully would be helpful in the future work

---

[attachment=14953]
ABSTRACT
Line following robot is a robo car that can follow a path. The path can be visible like a white line on the black surface (or vice-verse). As a result of this line following property it has many applications in future and now itself.
Line following robot with pick and placement capabilities are commonly used in manufacturing plants. These move on a specified path to pick the component from specified location and place them on desired locations.
Basically,a line-following robot is self operating robot that detects and follows a line drawn on the floor. The path to be taken is indicated by a white line on a black surface. The control system used must sense the line and manoeuvre the robot to stay on course while constantly correcting the wrong moves using feedback mechanism,thus forming a simple yet effective closed-loop system. As a programmer you get an opportunity to ‘teach’ the robot how to follow the line thus giving it a human-like property of responding to stimuli.
The robot has two sensors installed underneath the front part of the body, and two DC motors drive wheels moving forward. A circuit inside takes an input signal from two sensors and controls the speed of wheels’ rotation. The control is done in such a way that when a sensor senses a white line, the motor slows down or even stops. Then the difference of rotation speed makes it possible to make turns
1.INTRODUCTION
The line following robot, operates as the name specifies. It is programmed to follow a white line on a dark background and detect turns or deviations and modify the motors appropriately.
It consist of sensors,comparators,microcontroller and motor drivers.We uses darlington phototransistor as the sensor. The core of the robot is the AT89C51 microcontroller.Here it act as a decision making device.
It consist of two dc motors and driver ic to steer it. The differential steering system is used to turn the robot. In this system, each back wheel has a dedicated motor while the front wheels are free to rotate. To move in a straight line, both the motors are to be rotate at same speed.To manage a turn a motor is to stop at correct circumstances according to sensor output.
2.BLOCK DIAGRAM
3.BLOCK DIAGRAM EXPLANATION
Fig.1 show the block diagram of automated line following robot. It consist of mainly four parts: two sensors,two comparators,one decision making device and two motor drivers. The robot is built using micro controller AT89C51,motor driver L293D,operational amplifier LM324,phototransistor and a few discrete components.In the circuit, the sensor are used to detect the white strip on a black background. The sensor output is fed to the microcontroller, which takes the decision and gives appropriate command to motor driver L293D so as to move the motor accordingly
3.1 sensor: The sensor senses the light reflected from the surface and feeds the output to the comparator. When the sensor is above the white background the light falling on it from the source reflects to the sensor, and when the sensor is above the black background the light from the source doesn’t reflect to it. The sensor senses the reflected light to give an output, which is fed to the comparator.
3.2 comparator: The comparator compares the analogue inputs from sensors with a fixed reference voltage. If this voltage is greater than thereference voltage the comparator outputs a low voltage, and if it smaller the comparator generates a high voltage that acts as input for decision-making device(microcontroller).
3.3 microcontroller: The micro controller is programmed to make the robot move forward,turn right or left based on the input coming from the comparator. The outputs of the microcontroller are fed to the motor driver.
3.4 motor driver: The current supplied by the microcontroller to drive the motor is small. Therefore a motor driver ic is used. It provides sufficent current to drive the motor.

to get information about the topic light follower using robotics full report ,ppt and related topic refer the page link bellow

http://studentbank.in/report-light-follo...ull-report

http://studentbank.in/report-line-follow...ull-report

http://studentbank.in/report-line-follow...ull-report

to get information about the topic Mechanical Engineering Project Ideas List full report , refer the page link bellow

http://studentbank.in/report-mechanical-...ideas-list

http://studentbank.in/report-mechanical-...ect-topics

http://studentbank.in/report-mechanical-...ject-ideas

http://studentbank.in/report-mechanical-...g-projects

http://studentbank.in/report-mechanical-...r-students

http://studentbank.in/report-mechanical-...ect-1-list

http://studentbank.in/report-mechanical-...eas?page=2

http://studentbank.in/report-mechanical-...ist?page=7

---