Mech - User contributions [en]

IR Tracker

2008-03-21T10:24:30Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 2 MOSFETs
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic (includes original H-Bridge in design --> use MOSFETs instead)|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

PIC 

The PIC is the central controller of the IR Tracker.

 MOSFETs 

The MOSFETs are used as intermediate components between the PIC and the servo motors. It allows the Pittman motors to run in one direction.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the encoders on the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The L298N H-bridge ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-21T10:22:10Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 2 MOSFETs
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

PIC 

The PIC is the central controller of the IR Tracker.

 MOSFETs 

The MOSFETs are used as intermediate components between the PIC and the servo motors. It allows the Pittman motors to run in one direction.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the encoders on the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The L298N H-bridge ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-21T10:21:41Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 2 MOSFETs
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 


PIC 


The PIC is the central controller of the IR Tracker.


 MOSFETs 


The MOSFETs are used as intermediate components between the PIC and the servo motors. It allows the Pittman motors to run in one direction.


 Inverting Schmidt Trigger 


The Schmidt Trigger acts as an intermediate between both the PIC to the encoders on the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The L298N H-bridge ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-21T10:20:48Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 2 MOSFETs
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 


PIC 


The PIC is the central controller of the IR Tracker.


 MOSFETs 


The MOSFETs are used as intermediate components between the PIC and the servo motors. It allows the Pittman motors to run in one direction.


 Inverting Schmidt Trigger 


The Schmidt Trigger acts as an intermediate between both the PIC to the encoders on the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The L298N H-bridge ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:42:38Z

AliceZhao: /* Final Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 


PIC 


The PIC is the central controller of the IR Tracker.


 H-Bridge 


The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.


 Inverting Schmidt Trigger 


The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:40:17Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 


PIC 


The PIC is the central controller of the IR Tracker.


 H-Bridge 


The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.


 Inverting Schmidt Trigger 


The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:39:11Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 


PIC 

The PIC is the central controller of the IR Tracker.

 H-Bridge 

The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:37:22Z

AliceZhao: /* Mechanical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

 PIC 

The PIC is the central controller of the IR Tracker.

 H-Bridge 

The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:26:14Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

 PIC 

The PIC is the central controller of the IR Tracker.

 H-Bridge 

The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:25:59Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

 PIC 

The PIC is the central controller of the IR Tracker.

 H-Bridge 

The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:25:43Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

 PIC 

The PIC is the central controller of the IR Tracker.

 H-Bridge 

The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:25:13Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

 PIC 

The PIC is the central controller of the IR Tracker.

 H-Bridge 

The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

 Inverting Schmidt Trigger 

The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:24:34Z

AliceZhao: /* PIC */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

 PIC 
The PIC is the central controller of the IR Tracker.

===H-Bridge===
The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:23:39Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
The PIC is the central controller of the IR Tracker.

===H-Bridge===
The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:23:28Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
The PIC is the central controller of the IR Tracker.

===H-Bridge===
The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:21:10Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|450px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
The PIC is the central controller of the IR Tracker.

===H-Bridge===
The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:20:27Z

AliceZhao: /* Reflections */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
The PIC is the central controller of the IR Tracker.

===H-Bridge===
The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

===Objectives Met===
* Ability to locate the position of an IR emitter on two axises.
* Ability to rotate to align its plane to be normal to an IR emitter.
* Ability to continuously track an IR signal.

===Problems Encountered===
* (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
* (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
* (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
* (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

===Future Work===
* More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
* A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
* With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:19:53Z

AliceZhao: /* Results */

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
The PIC is the central controller of the IR Tracker.

===H-Bridge===
The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

===Final Design===

[[image:Final_Design.jpg|600px|center]]

===Video===

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:18:53Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
The PIC is the central controller of the IR Tracker.

===H-Bridge===
The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

===Outline of Code===

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

===main()===

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

===runsetup()===

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

===encodersave()===

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

===positioncount()===

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

===ircheck()===

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

===equalize()===

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

===servotrack()===

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:16:31Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
* On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
* Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
* The PIC is the central controller of the IR Tracker.

===H-Bridge===
* The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
* The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
* The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
* The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:16:03Z

AliceZhao: /* Electrical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

 

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
* On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
* Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

===Primary Components===

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

===PIC===
* The PIC is the central controller of the IR Tracker.

===H-Bridge===
* The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

===Inverting Schmidt Trigger===
* The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

===IR Detector / Emitter Pairs===
* The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

===Hall Sensors===
* The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:14:46Z

AliceZhao: /* Mechanical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

 

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===Primary Components===

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===Detecting Component===
* On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===Rotating Component===
* Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:13:54Z

AliceZhao: /* Mechanical Design */

[[image:IR_Tracker_Header.jpg|400px|right]]

 

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

===The primary components used in this device are:===

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

===* Detecting Component:===
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

===* Rotating Component:===
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:12:09Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|400px|right]]

 

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:11:47Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|400px|right]]

 

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T16:11:30Z

AliceZhao:

[[image:IR_Tracker_Header.jpg|400px|right]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

ME 333 final projects

2008-03-20T07:42:26Z

AliceZhao: /* IR Tracker */

'''[[ME 333 end of course schedule]]'''

__TOC__

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axises, and then tracks the emitter with a laser. [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 See Spot Run.]

 

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This wirelessly controlled robotic snake uses servo motors with a traveling sine wave to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.

 

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

 

=== [[Magnetic based sample purification]] ===

 

=== [[Continuously Variable Transmission]] ===

[[image:CVT_setup1.jpg|thumb|200px]]

A continuously variable tramsission is intended to provide a transition from low to high gear ratios while keeping the engine input running at the max efficient speed. It is achieved by a system of variable radius pulleys and a v-belt.

 

=== [[Granular Flow Rotating Sphere]] ===

This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

 

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

 

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

 

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

 

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

ME 333 final projects

2008-03-20T07:42:02Z

AliceZhao: /* IR Tracker */

'''[[ME 333 end of course schedule]]'''

__TOC__

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axises, and then tracks the emitter with a laser. [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 See Spot run.]

 

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This wirelessly controlled robotic snake uses servo motors with a traveling sine wave to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.

 

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

 

=== [[Magnetic based sample purification]] ===

 

=== [[Continuously Variable Transmission]] ===

[[image:CVT_setup1.jpg|thumb|200px]]

A continuously variable tramsission is intended to provide a transition from low to high gear ratios while keeping the engine input running at the max efficient speed. It is achieved by a system of variable radius pulleys and a v-belt.

 

=== [[Granular Flow Rotating Sphere]] ===

This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

 

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

 

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

 

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

 

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

IR Tracker

2008-03-20T07:30:55Z

AliceZhao: /* Electrical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T07:30:02Z

AliceZhao: /* Electrical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* PIC
** The PIC is the central controller of the IR Tracker.

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

File:Hall Sensors.jpg

2008-03-20T07:29:01Z

AliceZhao:

File:IR Detector Emitter.jpg

2008-03-20T07:28:33Z

AliceZhao:

IR Tracker

2008-03-20T07:22:19Z

AliceZhao: /* Results */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

File:Circuit Top View.jpg

2008-03-20T07:20:12Z

AliceZhao:

IR Tracker

2008-03-20T07:09:44Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this device are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T07:09:23Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

[[image:Mechanical_Design.jpg|center|Mechanical Design|700px]]

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T07:08:34Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design.jpg|center|Mechanical Design|thumb|600px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

File:Rotating Component.jpg

2008-03-20T07:07:46Z

AliceZhao:

IR Tracker

2008-03-20T07:06:09Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T07:05:56Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T07:00:26Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design_left.jpg|center|Mechanical Design|thumb|300px][image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T06:59:56Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design_left.jpg|center|Mechanical Design|thumb|300px]]
[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T06:58:22Z

AliceZhao: /* Mechanical Design */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design_left.jpg|right|Mechanical Design|thumb|300px]]
[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

File:Mechanical Design.jpg

2008-03-20T06:57:32Z

AliceZhao:

IR Tracker

2008-03-20T06:32:45Z

AliceZhao: /* "Spot" the IR Tracker */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T06:29:45Z

AliceZhao: /* "Spot" the IR Tracker */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|400px|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T06:28:31Z

AliceZhao: /* Results */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

<center> "See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project. </center>

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

IR Tracker

2008-03-20T06:28:04Z

AliceZhao: /* Results */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|300px|center]]

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.

File:Final Design.jpg

2008-03-20T06:25:36Z

AliceZhao:

IR Tracker

2008-03-20T06:21:34Z

AliceZhao: /* Results */

=="Spot" the IR Tracker==

[[image:IR_Tracker_Header.jpg|center]]

==Team Members==

[[Image:IR_Tracker_Team.jpg|right|Left to right: Matt, Mark and Alice|thumb|300px]]

* Mark Straccia (Mechanical Engineering, Class of 2009)
* Matt Turpin (Mechanical Engineering, Class of 2009)
* Alice Zhao (Electrical Engineering, Class of 2008)

 

==Overview==

The goal of this project was to create a device that would follow a moving infrared light. The IR Tracker does this by continuously detecting the position of an infrared emitter in two axises, and then tracking the emitter with a laser.

The IR Tracker follows two major steps: (1) Identify the position of the IR emitter (2) Rotate the device to align itself with the IR emitter.

# The IR Tracker finds the location of the maximum infrared intensity in both the x-axis and y-axis. Two encoders continuously record the position of the IR emitter based on intensity levels detected by two IT detectors.
# Given the information about the location of the IR emitter, the device rotates itself in two dimensions to adjusts its plane to be normal to the IR emitter. At this point, the laser should point to the IR emitter.

We will discuss the mechanical design, electrical design, PIC code, resulting project and our team reflections.

==Mechanical Design==

[[image:Mechanical_Design.jpg|right|Mechanical Design|thumb|300px]]

The primary components used in this circuit are:

* 2 Pitman Motors
* 2 RC Servos
* 1 Turntable (6031K17, McMaster-Carr, $2.20, readily available)
* 1 Cylindrical Bearing
* 1 Laser
* Mirror
* Plexiglas

 

[[image:Detecting_Component.jpg|right|Detecting Component|thumb|300px]]

* Detecting Component:
** On the main plane of the device, two encoders are placed perpendicular to each other (able to track on two axises). Mirrors are placed on the output shafts of the two encoders at 45 degree angles. Two infrared detectors are placed in line with the encoders. While the encoders are constantly spinning, the mirrors detect light from the IR emitter and bounce the light to the IR detectors.

 

[[image:Rotating_Component.jpg|right|Rotating Component|thumb|300px]]

* Rotating Component:
** Below the main plane of the device, two servos are used to rotate the entire device to align the main plane to be normal to the emitter. The main plane is attached to a block of Plexiglas that surrounds a cylindrical bearing. This bearing allows the main plane to rotate along the y-axis. This block of Plexiglas is mounted on a turntable which allows the main plane to rotate along the x-axis.

 

==Electrical Design==

The primary components used in this circuit are:

* 1 PIC (18F4520)
* 2 IR Detector / Emitter Pairs
* 2 Hall Sensors & Small Magnets
* 1 H-Bridge (L298)
* 1 Inverting Schmidt Trigger (74HC14)

[[image:Circuit_Diagram.jpg|left|IR Tracker Schematic|thumb|500px]]
[[image:Circuit_Top_View.jpg|right|IR Tracker Top View|thumb|500px]]

 

* PIC
** The PIC is the central controller of the IR Tracker.

[[image:IR_Detector_Emitter.jpg|left|IR Detector|thumb|200px]]

* IR Detector / Emitter Pairs
** The IR Detector detects the intensity of IR light coming from the IR Emitter. Over each revolution of the encoder's output shaft, the location of the maximum IR intensity is recorded. This information is given to the PIC to determine the servo's next position.

 

[[image:Hall_Sensors.jpg|left|Hall Sensors|thumb|200px]]

* Hall Sensors
** The Hall Sensors are used as a position marker for the encoders. They are located just below the output shafts of the encoders. A small magnet is placed on the side of the output shafts. As both encoder shafts spin, the Hall Sensor detects the location of the magnet. The purpose of the Hall Sensors is to use this information to sync the rotations of the two encoder shafts.

 

* H-Bridge
** The H-Bridge is an intermediate component between the PIC and the servo motors. It allows the servo motors to run forwards and backwards.

* Inverting Schmidt Trigger
** The Schmidt Trigger acts as an intermediate between both the PIC to the motors and the PIC to the Hall Sensors. It helps filter out noisy signals and invert signals to be readable for the PIC, respectively.

==Code==

[[media:IR_Tracker_Code.c|See full code here]]

Here is a general outline of what the IR Tracker does:

# Spin encoder shafts
# Record current position of the servo
# Determine location of the maximum IR intensity detected
# Convert encoder position to servo position
# Rotate the main plane to the new servo position
# Sync rotations of the two encoder shafts
# Repeat steps 2-6

This is the main function of our code:

<pre>
void main()
{
runsetup();

while (TRUE)
{
encodersave();
positioncount();
ircheck();
equalize();
}
}
</pre>

The five functions it encompasses are described in detail below.

 runsetup() 

The interrupts for both servos and Hall sensors are set, and motors begin to spin at full velocity. This function is only called once at the beginning of the main function.

<pre>
void runsetup()
{
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_1); //External input from quadrature encoder 0
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); //External input from quadrature encoder 1
setup_timer_2(T2_DIV_BY_4, 255, 5); //Servo incrememnting timer at 1 kHz
setup_timer_3(T3_INTERNAL | T3_DIV_BY_4); //Servo reseting timer

enable_interrupts(INT_TIMER2); //Enable ISR2 for servo
enable_interrupts(INT_TIMER3); //Enable ISR3 for servo
enable_interrupts(INT_EXT); //Enable Interrupt for Hall sensor X
enable_interrupts(INT_EXT1); //Enable Interrupt for Hall sensor Y
enable_interrupts(global);

setup_ccp1(ccp_pwm); //Setup PWM1
setup_ccp2(ccp_pwm); //Setup PWM2

set_timer0(0); //Clear starting point of counters
set_timer1(0);

set_PWM1_duty(0); //Motors off for startup
set_PWM2_duty(0);

for(ii=0;ii<3;ii++) //Start up flashing lights
{
output_d(0x55);
delay_ms(100);
output_d(0);
delay_ms(100);
}

set_PWM1_duty(1023); //Motors start at full velocity
set_PWM2_duty(1023);
}
</pre>

 encodersave() 

This records the current servo positions in the both the x and y direction.

<pre>
void encodersave() //Counters will return the number of pulses to the inputs.
{
PositionCountX = get_timer0(); //Relative position of the X encoder
delay_us(10);

PositionCountY = get_timer1(); //Relative position of the Y encoder
delay_us(10);
}
</pre>

 positioncount() 

This uses LEDs to represent where in the rotation the mirrors are, with one LED for each axis. The LEDs are on for half of the rotation and off for the other half.

<pre>
void positioncount() //Gives visual information about where in the rotation the mirrors are
{
if (PositionCountX >4875)
{
output_high(pin_D3);
}
else if(PositionCountX>0)
{
output_low(pin_D3);
}
if (PositionCountY > 4875)
{
output_high(pin_D4);
}
else if(PositionCountY>0)
{
output_low(pin_D4);
}
}
</pre>

 ircheck() 

This finds the location of maximum infrared light in both the x-axis and y-axis. This information is originally collected as an encoder position count value, is converted into an angle in degrees and is then converted again into servo position count value, so that the servo can move to the appropriate location.

<pre>
void ircheck() //Check to see where in the rotation
{
if(PositionCountX<4875) //First half of rotation, facing up
{
if(input(PIN_C6)==0) //If IR detector is detecting encoded signal
{
output_high(PIN_D5); //Gives visual representation
MomentX+=PositionCountX; //Increase moment count by position
MomentCountX+=1; //Increase count of moments
}
else
{
output_low(PIN_D5); //Clear B5 if mirror is facing down
}
}
else if((PositionCountX>=4875)&&(MomentCountX>5)) //Runs when this function is called and IR detector
{
AverageAngleX = (MomentX/MomentCountX); //Average the moment to give the center of IR in terms of motor encoder counts

if (((AverageAngleX)>650)&&((AverageAngleX)<4800))
{
AnglePositionX = 3647-23*AverageAngleX/34; //Convert motor encoder counts to servo values

if (ServoCurrent[0] + AnglePositionX < 1950) //Less than 90 degress
{
ServoTargetX = 400;
}
else if (ServoCurrent[0] + AnglePositionX> 4250) //Greater than 450 degrees
{
ServoTargetX = 2700;
}
else //between 90 and 450 degrees
{
ServoTargetX = AnglePositionX + ServoCurrent[0] - 1550;
}
}
MomentX = 0; //reset moment variables
MomentCountX = 0;
}

if(PositionCountY<4875)
{
if(input(PIN_C5)==0)
{
output_high(PIN_D6);
MomentY+=PositionCountY;
MomentCountY+=1;
}
else
{
output_low(PIN_D6);
}
}
else if((PositionCountY>=4875)&&(MomentCountY>5))
{
AverageAngleY = (MomentY/MomentCountY);

if (((AverageAngleY)>650)&&((AverageAngleY)<4800))
{
AnglePositionY = 3647-23*AverageAngleY/34;

// find target location in terms of servo counts
if (ServoCurrent[1] + AnglePositionY < 1950) //less than 90 degress
{
ServoTargetY = 400;
}
else if (ServoCurrent[1] + AnglePositionY> 4250) // greater 450 deg
{
ServoTargetY = 2700;
}
else
{
ServoTargetY = AnglePositionY + ServoCurrent[1] - 1550;
}
}
MomentY = 0;
MomentCountY = 0;
}
}
</pre>

 equalize() 

This syncs the speed and direction of the rotation of the two encoder motors.

<pre>
void equalize() //puts motors in phase with each other
{
if(PositionCountX>PositionCountY)
{
set_PWM1_duty(850);
set_PWM2_duty(1023);
}
else if (PositionCountX<PositionCountY)
{
set_PWM2_duty(850);
set_PWM1_duty(1023);
}
}
</pre>

 servotrack() 

While this function isn't in the main function, it is called in one of the interrupts. Its purpose is to slowly move the servos from their current location to its destination.

<pre>
void servotrack() //Slowly adjusts the pulsing of the servo to place the plan in the appropriate location
{
if(((SlowServoX>15)&&(abs(ServoTargetX-ServoCurrent[0])>5))||((SlowServoX>8)&&(abs(ServoTargetX-ServoCurrent[0])>125))
||((SlowServoX>3)&&(abs(ServoTargetX-ServoCurrent[0])>450))||SlowServoX>100) //Can be used to slow down motion of Servos
{
if (ServoCurrent[0] < ServoTargetX - ServoMove)
{
ServoNextX = ServoCurrent[0] + ServoMove;
ServoCurrent[0] = ServoNextX;
}
else if (ServoCurrent[0] > ServoTargetX + ServoMove)
{
ServoNextX = ServoCurrent[0] - ServoMove;
ServoCurrent[0] = ServoNextX;
}
else
{
ServoCurrent[0] = ServoTargetX;
}
SlowServoX=0;
}
if(((SlowServoY>15)&&(abs(ServoTargetY-ServoCurrent[1])>5))||((SlowServoY>8)&&(abs(ServoTargetY-ServoCurrent[1])>125))
||((SlowServoY>3)&&(abs(ServoTargetY-ServoCurrent[1])>450))||SlowServoY>100)

{
if (ServoCurrent[1] < ServoTargetY - ServoMove)
{
ServoNextY = ServoCurrent[1] + ServoMove;
ServoCurrent[1] = ServoNextY;
}
else if (ServoCurrent[1] > ServoTargetY + ServoMove)
{
ServoNextY = ServoCurrent[1] - ServoMove;
ServoCurrent[1] = ServoNextY;
}
else
{
ServoCurrent[1] = ServoTargetY;
}
SlowServoY=0;
}

SlowServoX++;
SlowServoY++;
}
</pre>

==Results==

Our final design:

[[image:Final_Design.jpg|600px|center]]

"See Spot Run": Click [http://depot.northwestern.edu/mht363/public_html/IR%20Track/Mar%2019%20IR%20tracker.mp4 here] to see a movie of our final project.

==Reflections==

Overall, our team is very satisfied with our end result.

* Objectives Met:
** Ability to locate the position of an IR emitter on two axises.
** Ability to rotate to align its plane to be normal to an IR emitter.
** Ability to continuously track an IR signal.

* Problems Encountered:
** (Mechanical) Initially, the device had very shaky movements. We added additional screws to make the device more stable.
** (Electrical) We added Schmidt Triggers to clean up the noisy signals from the servo motors to the PICs.
** (Code) Originally coded to track direction of change of the IR emitter and supposed to move accordingly. We encountered a lot of noise. We changed the code to find the exact position of the IR emitter instead.
** (Electrical) The Schmidt Triggers ended up heating up the entire circuit. In our final design, we chose to use MOSFETS in their place.

* Future Work:
** More powerful servos and a more accurately calculated counterweight would help smooth the movement of the device.
** A more sensitive IR detector could track lower intensities of IR light in a room, instead of specifically an IR emitter.
** With more precise measurements of the relationship between the encoder and servo values, the IR Tracker could more accurately determine the position of an IR signal.