IR PROXIMITY SENSOR

INTRODUCTION
The idea to create a type of close proximity radar system came from a student in
one of my classes. We went ahead and decided to streamline the idea into the
course as one of the projects we'd build.
           After a week or two of prep time we finally agreed on the project setup &
parts that we'd use. This is not meant to be an advanced project, thusly the
difficulty is set at medium.

           Below is an example of what short range personal radar could be used
for. It's meant to be a bit comical so feel free to laugh!

Purpose & Overview of this project

           The goal of this project is to create a working ir radar system. The system
will only be required to measure close proximity at an angle of 90 degrees as seen
in the example above. The range of system is roughly 4-30cm, 20-150cm & 1m-
5.5m depending upon which sensor you choose to use.
           The outcome of this project will shape future projects where we try to
integrate such a radar system to help navigate mobile robots through the real
world.

Parts List Details

           You may or may not be familiar with the parts above so a picture of each
item has been included to help give you an idea of what they look like. Three new
objects that we've never seen before appear in this project; Servos, the
74HCT373 & IR Sensors. Tutorials on Servos & IR Sensors should be up
soon but for the 74HCT373 I've given a brief overview of it below. You can always
check out the datasheet for the chip by search google for "74HCT373

The 74HCT373
           This chip is an octal d flip-flop tri-state latch. In english that means
that this chip is capable of storing 8 bits of digital logic and holding that memory
until it is cleared or changed via the LE-Latch Enable pin.

How It Works
     •Control Pins LE & OE
     •8 Data Inputs D0-D7
     •8 Data Outputs Q0-Q7

1
     •Vcc & GND.
           Output Enable allows Q0-Q7 to output the data currently held in the D-
FlipFlop Latches.
           Latch Enable enables the data currently on D0-D7 to overwrite whatever
the D-FlipFlop Latches currently have.

           So that will do it for the parts used in this project. Let's move onto the
schematic! If you have any questions about the parts just ask in the forums.

The 74HCT373

Schematic Overview
           The schematic for this project is much more complicated than previous
projects. There are four main features in our design. (1) We will be able to
program the pic on the board we develop. (2) We will be controlling a servo. (3)
We will be taking data input from an IR Proximity sensor. (4) We will set 36
LEDs to display proper output to respresent what the IR sensor sees.

Schematic Specifics
•Power Circuit
           The power circuit is a 9v Battery hooked up to the LM7805 with a 1uF
capacitor hooked to output & ground of the LM7805 to keep a steady 5v DC.
•Programming Circuit
           The programming circuit is made by hooking up two pins from the PIC to
the programmer and allowing the programmer's pin 1 access to the MCLR*/Vpp-

2
Pin1 on the PIC. We put a rectifier diode in there for safety as well.
•IR Proximity Sensor
           The IR Sensor only uses 1 pic from the pic, PIN 2 - RA0. It will use the
analog feature of this pin to get an ADC value as the proximity sensor only
outputs analog voltages. This value will tell us the if anything is near the sensor in
our enviornment.
•LEDs Output
           There are 40 LEDs in total. Since each 74HCT373 can control up to 8
leds; 40/8 = 5 we'll need to use 5 74HCT373's to be able to control all 40
LEDs. It is important to notice on the schematic that a common data bus is used
between all the 5 chips.

The Theory
           This project uses three main devices to create the personal radar system.
The IR Range sensor gives output, the pic microcontroller processes it and
then displays the output on the led array

Using Different Sensors

           An interesting thing about the sharp IR sensors that I've used in this
project is that they all follow the same voltage curve so one program can literally
fit all sensors. You only have to be aware of the sensor that is being used to make
sense of the distance output by the leds.

Our Implementation
           We just got a brief high-level overview of the theory, for more indepth
explainations of the theory please go back to any of the tutorials (pic, servos or
ir sensors). Now let's take a look at the finished hardware device:

This is how the device looks when it is completed. So let's move onto the next
section and actually assemble the schematic on the proto board and build the
hardware enclosure.

Hardware Design
           The plastic enclosure seen below wasn't mentioned in the parts list. It's just
a generic enclosure you can buy from any electronics distributor or manufacturer.
           The first thing we need to do is to drill holes for all the 36 leds that will be
in our circuit and to e-poxy the leds into them. Additionally I put a little epoxy
on led leads before sticking them into sip sockets so they'd stay on.
           Now we'll get the board soldered in and start to wire-wrap the

3
schematic. You should be able to fit all the ic's onto the board in a small enough
space to fit into your enclosure.

          The above picture is a sample of how the board should look during initial
stages. Once you have everything wirewrapped it will be quite a mess of wires
but should look something like this:
           The final look at the hardware design is what allows the personal radar
system to be used 'remotely'. We use a length of wire about 2-4 meters long when
connecting the servo & ir sensor. We put a hole in the front of the enclosure for
these wires:
With the hardware completed lets move onto the software portion of the project.
This is definitely the funner part of this project, nore more soar fingers from
wire-wrapping.

The Software
           The IR range software for this project has three main portions to it.
    -Servo Control
    -Led Output Control
    -A/D Input

           Since the software for this project won't fit all on one page I'll explain these
three elements and how they're implemented. If you have any lasting questions
about the software just go to the forums and ask! The program is heavily
commented so it should be readable.

Servo Control
           The method used for servo control is via timers & interrupts. A 50Hz
signal is generated by two seperate interrupts that work together to create desired
pulses that make the servo pan left and right in small steps so as to quiet the
servo's squeaking movement noise.

Led Output Control

           The leds are all controlled via the 74LS373/74HCT373 latches. The pic
inturn controls these devices by switching the control lines. The system
constantly updates the latch information which can be seen by the led output.

A/D Input
           The IR range sensor output is in the form of a varying analog voltage. We
use the a/d converter to find the value of this voltage which will tell us the
distance that objects are away from the ir range sensor. Software loaded &

4
hardware completely built. Let's test it out! Depending on the sensor you use,
different output will be visible on the leds. Sensors to choose from: GP2D120,
GP2Y0A21YK or GP2Y0A700K0F

Coding
/*
Author: Chris @ http://www.pyroelectro.com
Date: 2/3/2008

Program:
This program makes a servo pan back and forth and takes
data at 5 different points, interprets that data & displays
it on the output leds using PORTD & PORTC to talk with
the 74LS373's.
*/

//Initial Includes
#include <p18f452.h>
#include <timers.h>
#include <delays.h>
#include <adc.h>
#include <stdlib.h>

//Servo Initialization
int servo0 = 0xFC17;

//More Initializations
int radar_direction = 0;
int whichway = 0;
int count = 0;
int result = 0;
int round = 0;

//Function Declarations
void InterruptHandlerHigh (void);
int Ir_Data_Eval(int, int);

void main(void)
{

//Allow Interrupts
RCON = 0b000000000;
INTCON = 0b10100000;

//Setup & Open A/D, Timers

OpenTimer0( TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_2 );
OpenTimer1( TIMER_INT_ON & T1_16BIT_RW & T1_SOURCE_INT & T1_PS_1_2 &
T1_OSC1EN_OFF & T1_SYNC_EXT_OFF );

//Initialize Timers
WriteTimer0( 0xB1DF );

5
WriteTimer1( 0xFC17 );

//Initialize Port Directions

TRISD = 0x00;
TRISB = 0x00;
TRISC = 0x00;

//Initially Light Up All Leds & Turn Them Off

PORTB = 0xFF;
PORTD = 0xFF;
Delay10TCYx(100);
PORTD = 0x00;
Delay10KTCYx(100);

PORTB = 0x00;
PORTD = 0xFF;
Delay10TCYx(100);
PORTD = 0x00;
Delay10KTCYx(100);

//Infinite While Loop

while(1)
{

//If radar is at one of 5 spots take a/d & output it to the

leds
switch(radar_direction)
{

case 0:

ConvertADC();
while( BusyADC() );
result = ReadADC();

PORTB = Ir_Data_Eval(result, 1);

PORTD = 0x01;
Delay10TCYx(10);
result = 0;
PORTD = 0x00;
break;
case 1:

ConvertADC();
while( BusyADC() );
result = ReadADC();

PORTB = Ir_Data_Eval(result, 0);

PORTD = 0x02;
Delay10TCYx(10);
result = 0;
PORTD = 0x00;
break;
case 2:

6
 ConvertADC();
while( BusyADC() );
result = ReadADC();

PORTB = Ir_Data_Eval(result, 0);

PORTD = 0x04;
Delay10TCYx(10);
result = 0;
PORTD = 0x00;
break;
case 3:

ConvertADC();
while( BusyADC() );
result = ReadADC();

PORTB = Ir_Data_Eval(result, 0);

PORTD = 0x08;
Delay10TCYx(10);
result = 0;
PORTD = 0x00;
break;
case 4:

ConvertADC();
while( BusyADC() );
result = ReadADC();

PORTB = Ir_Data_Eval(result, 0);

PORTD = 0x10;
Delay10TCYx(10);
result = 0;
PORTD = 0x00;
break;
}
}
}

//INTERRUPT CONTROL
#pragma code InterruptVectorHigh = 0x08 //interrupt pointer
address (0x18 low priority)
void InterruptVectorHigh (void)
{
_asm //assembly code starts
goto InterruptHandlerHigh //interrupt control
_endasm //assembly code ends
}
#pragma code
#pragma interrupt InterruptHandlerHigh //enf.

void InterruptHandlerHigh() // declaration of InterruptHandler

{//this gets ran when ever the timers flop over from FFFF->0000

7
 if(INTCONbits.TMR0IF) //check if TMR0
interrupt flag is set
{
WriteTimer0( 0xB1DF );
WriteTimer1( 0xFC17 );
count = 0;
INTCONbits.TMR0IF = 0; //clear TMR0
flag
}
if(PIR1bits.TMR1IF == 1 && PIE1bits.TMR1IE == 1) //if set
controls the first servo
{
count++;
switch(count){
case 1: PORTC = 0x01; // First Stage
WriteTimer1( servo0 );
break;
default: PORTC = 0x00; // Left Gripper
WriteTimer1(0);
break;
}

PIR1bits.TMR1IF = 0; //clear Timer1

flag
PIE1bits.TMR1IE = 1; //clear Timer1
enable flag set to zero

/*

Begin Direction Control

*/
//Move the Servo In Small Steps
if(whichway)
servo0+=5;
if(!whichway)
servo0-=5;

//When 90 degrees or 0 degrees is reached, switch direction

if(servo0 <= 0xF82F ){
whichway = 1;
round++;
}
if(servo0 >= 0xFC17){
whichway = 0;
round++;
}

/*

End Direction Control

*/

8
/*

Begin Radar Directional Lighting Control

*/

//If 120 < servo0 < 130

if(servo0 > 0xF8A7 && servo0 < 0xF8B1)
{
if(whichway == 0)
radar_direction = 0;
if(whichway == 1)
radar_direction = 1;
}

//If 370 < servo0 < 380

if(servo0 > 0xF9A1 && servo0 < 0xF9AB)
{
if(whichway == 0)
radar_direction = 1;
if(whichway == 1)
radar_direction = 2;
}

//If 620 < servo0 < 630

if(servo0 > 0xFA9B && servo0 < 0xFAA5)
{
if(whichway == 0)
radar_direction = 2;
if(whichway == 1)
radar_direction = 3;
}

//If 870 < servo0 < 880

if(servo0 > 0xFB95 && servo0 < 0xFB9F)
{
if(whichway == 0)
radar_direction = 3;
if(whichway == 1)
radar_direction = 4;
}

/*

End Radar Directional Lighting Control

*/

}
INTCONbits.GIE = 1; //re-enable all
interrupts
}

int Ir_Data_Eval(int ir_data, int isCHIP0)

9
{
// @ 70cm+
if(ir_data > 0x171 && ir_data <= 0x19E){
if(isCHIP0)
return 0xC0;
else
return 0x40;
}
// @ 60cm+
else if(ir_data > 0x19E && ir_data <= 0x1C3 ){
if(isCHIP0)
return 0xA0;
else
return 0x20;
}
// @ 50cm+
else if(ir_data > 0x1C3 && ir_data <= 0x1EB ){
if(isCHIP0)
return 0x90;
else
return 0x10;
}

// @ 40cm+
else if(ir_data > 0x1EB && ir_data <= 0x20D ){
if(isCHIP0)
return 0x88;
else
return 0x08;
}

// @ 30cm+
else if(ir_data > 0x20D && ir_data <= 0x262 ){
if(isCHIP0)
return 0x84;
else
return 0x04;
}

// @ 20cm+
else if(ir_data > 0x262 && ir_data <= 0x2C6 ){
if(isCHIP0)
return 0x82;
else
return 0x02;
}

// @ 10cm+
else if(ir_data > 0x2DA){
if(isCHIP0)
return 0x81;
else
return 0x01;
}

10
 //If chip 0 make sure to turn on the very first led
if(isCHIP0)
return 0x80;

return 0x00;
}

11