1. Washington State University
EE3234 Microprocessor Systems
Final Project
Line Following Motor Robot Kit with PIC32
Nathan Wendt
11401887
Date: Dec. 11, 2015

2. 1.0 Objective:
The objective of this project was to use the PIC32 motor robot kit and 4 infrared sensors
to identify and react to a small black path (created with electrical tape). The robot must have
two modes of operation: Tracking mode, and search mode. In tracking mode, the robot is to
continue following the line until the sensors cannot detect the line anymore. Once the sensors
have lost the track, the robot enters search mode. In search mode, the robot is to travel a
discrete distance forward, then reverse, then turns 90* and repeats for each North, East, South,
and West directions. While in search mode, at any time that the sensors detect the line, search
mode must be broken and track mode will be entered. As such our robot should be able to
traverse a simple electrical tape course with 90* corners, T crossroads, gaps, and curves.
1.1 Design Requirements:
1. Assemble the robot to the manufacturer’s specifications.
2. Use PmodHB5 H-bridges to control the DC motors.
3. Use the PmodLS1 and IROS sensors to detect the path
4. The robot must contain 2 modes of operation:
-Search mode: Travels 3 ft north, 3 ft reverse, 90* turn and repeat
for East, South, West
-Track mode: While a sensor has detected a line the robot will
follow the line via a logical mapping of commands to the sensor
inputs.
2.0 Introduction:
This lab uses a high-level programming language and compiler, specifically, C in MPLabX.
We used output compare registers in PWM mode without a fault pin to manage the duty cycle
of the motors. There are a total of 5 OC modules. We will use OC2 and OC3. We use the value
of PR2 to determine the PWM period and the value of OCxRS to determine the duty cycle.
Overall this lab can be broken into two pieces: external hardware peripherals and internal
peripherals. The external hardware used are two DC motors, two PmodHB5’s to control the
output of the DC motors, and the PmodLS1 with the 4 IROS infrared detectors. The internal
peripherals used are Timer1 (used as the basis for the interrupt), Timer2 (used to set OC2 and
OC3 PWM periods), Timer3 is used for the operations of the robot.3.0 Design:
3.1 Hardware
The hardware used is the PIC32, two DC motors controlled by H-bridges
(PmodHB5), and the 4 IROS sensors read by the PmodLS1. The duty cycles of the DC
motors are controlled within the output compare modules while the direction of the
motor is controlled by the H-bridge. A diagram of the H-bridge operation is shown on
the page below:

3. Figure 1: PmodHB5 4 pin operations
The PmodLS1 takes the inputs from the IROS infrared detectors to determine the
path. The IROS emit an infrared signal and assert high if they receive a reflection. As
such, the sensors read 1 over white areas and 0 over the electrical tape. Each of these
inputs is then assigned to a port and then the software of the robot uses conditional
logic to decide on the robot’s operation.
3.2 Software
We used the MPLabX IDE in Assembly to program our pic32. For the most part,
the software of this project was very straight forward. The OC modules were
programmed to operate in PWM mode. OC2 and OC3 each controlled the duty cycle of
one of the motors and were generally set together. The basic motion functions of the
robots were forward, reverse, right, left, and soft right (right and left have the wheels
spinning opposite while soft right had only one wheel spinning). Soft right was needed
to get past T’s and coming across horizontal paths in search mode. Additionally, there
were two functions to control which motion operation was used. These were the search
and track functions. Track used a logical mapping of binary representations of sensor
readings to control whether the robot used forward, right, left, or soft right. In track
mode, the robot simply followed a pattern of forward distance x, reverse distance x, and
turn 90* for each unique direction. The final key piece to the operation of the line-
tracking robot was the timer1 interrupt. Using a timer size of 13500 tics at 10MHz ended
up being the perfect refresh rate for the robot to operate smoothly. The timer1
interrupt contained 4 conditional statements that decided whether the robot was
supposed to start operations, cease operations, operate in track mode, or operate in
search mode.

4. The duty cycle of the motors is controlled by the OC registers in PWM mode. The figure below
shows how the period of the associated timer, and the OCxRS registers are used to control duty
cycles with pulse width modulation:
Figure 2: Duty cycle specified by OCxRS in PWM mode
4.0 Procedure:
The procedure for this lab is straight forward:
- Construct the motor robot kit drone with the IROS sensors
- Devise and write the C source code to control the robot’s operations
- Calibrate the duty cycles and timings
- Stop the robot from traveling down stairs
5.0 Results and Conclusion:
5.1 Results
Most of the issues I had in this lab were not solved by logical proceedings. The first
attempt to create the code for the robot simply would not do anything for the robot. I
eventually decided to create a new project file and copy over the code and it decided to
register. From the point it was basic debugging and determining the proper timings for
everything. The final product of my efforts was a fast acting and accurate line-following robot
that preferred to turn right. The reason I say this is when all sensors were asserted low (such as
when the robot came across a perpendicular track while in search mode or if a T crossroad was
hit in track mode) the robot’s logic told it to soft turn right (on wheel turn).
5.2 Conclusion:
In hindsight, this project would probably take me 20 minutes to complete so I think that
is a testament to lessons learned. My main issues were in understanding the operation of the
timer interrupts. As funny as it may be, I did not realize that the interrupt was triggered when
the PR limit was reached. Once that registered in my brain, the rest of the project was straight
forward. I also found that calling functions from the interrupt caused inefficiencies in the
robots movements and as such I created a run() function that controlled the function calls while

5. the timer1 interrupt simply set the robot’s state (just an enumerated type for track, search, and
stop). My final code came out fairly concise at under 300 lines and there is even more
optimization that could be done to the search operation.

6. Appendix A: Source code
#include <xc.h> /* contains Vector Name/Number Macros */
#include <sys/attribs.h> /* contains __ISR() Macros */
#include <stdio.h>
/* Oscillator Settings
*/
#pragma config FNOSC = PRIPLL // Oscillator selection
#pragma config POSCMOD = EC // Primary oscillator mode
#pragma config FPLLIDIV = DIV_2 // PLL input divider
#pragma config FPLLMUL = MUL_20 // PLL multiplier
#pragma config FPLLODIV = DIV_1 // PLL output divider
#pragma config FPBDIV = DIV_8 // Peripheral bus clock divider
#pragma config FSOSCEN = OFF // Secondary oscillator enable
#pragma config IESO = OFF // Internal/external clock switchover
#pragma config FCKSM = CSDCMD // Clock switching (CSx)/Clock monitor(CMx)
#pragma config OSCIOFNC = OFF // Clock output on OSCO pin enable
#pragma config UPLLEN = ON // USB PLL enable
#pragma config UPLLIDIV = DIV_2 // USB PLL input divider
/* Other Peripheral Device settings
*/
#pragma config FWDTEN = OFF // Watchdog timer enable
#pragma config WDTPS = PS1024 // Watchdog timer post-scaler
#
/* Code Protection settings
*/
#pragma config CP = OFF // Code protection
#pragma config BWP = OFF // Boot flash write protect
#pragma config PWP = OFF // Program flash write protect
//typedef enum{Forward, Stop1, Backward, Stop2, Turn, Stop3} Mode;
typedef enum{Search, Track, Stop} Mode;
Mode mode= Stop;
/** LOCAL PROTOTYPES ********************************************************/
void InitializeSystem();
void Initialize_Timer1();
void Initialize_Timer2();
void Initialize_Timer3();
void Initialize_OC();// Initialize hardware and global variables
void Initialize_IO();
void Initialize_IC();

7. void Motor_Forward();
void Turning(int speed, int direction);
void Turn1(int speed, int direction);
void Stop_Motion();
void Motor_Backward();
void Search_Mode();
void Track_Mode();
void InitializeSensors();
void Interrupts_enable();
void Run();
/** main() ********************************************************************/
int main(void)
{
InitializeSystem();
Interrupts_enable();
while(1)
{
Run();
}
}
void Run()
{
if (mode == Stop)
while (mode == Stop)
Stop_Motion();
if (mode == Track)
while (mode == Track)
Track_Mode();
if (mode == Search)
while (mode == Search)
Search_Mode();
}
void InitializeSystem(){
Initialize_IO();
Initialize_OC();
Initialize_Timer1();
Initialize_Timer2();
Initialize_Timer3();
}

8. void Initialize_IO()
{
TRISDbits.TRISD6 =0;
TRISDbits.TRISD7 =0;
TRISAbits.TRISA6 = 1;
TRISAbits.TRISA7 = 1;
TRISDbits.TRISD1 =0;
LATDbits.LATD1 = 0;
TRISDbits.TRISD2 =0;
LATDbits.LATD2 =0;
TRISGbits.TRISG12= 1;
TRISGbits.TRISG13 = 1;
TRISGbits.TRISG14 = 1;
TRISGbits.TRISG15 = 1;
}
void Initialize_OC() // output compare
{
OC2CONbits.OCM =6;
OC2R = 0;
OC2RS = 0;
OC2CONbits.ON=1;
OC3CONbits.OCM =6;
OC3R = 0;
OC3RS = 0;
OC3CONbits.ON = 1;
/* Set Interrupt Controller for multi-vector mode */
}
void Initialize_Timer1(){
T1CONbits.TON = 0;
T1CONbits.TCKPS = 3;
PR1 = 13500;
TMR1 = 0;
T1CONbits.ON =1;
}
void Initialize_Timer2(){
T2CONbits.TON = 0;
T2CONbits.TCKPS = 7;
PR2 = 2000;
TMR2 = 0;

9. T2CONbits.ON =1;;
}
void Initialize_Timer3(){
T3CONbits.TON = 0;
T3CONbits.TCKPS = 7;
PR3 = 0xFFFF;
TMR3 = 0;
T3CONbits.ON =1;;
}
void Interrupts_enable() //// Interrupt for Timer1
{
IFS0bits.T1IF =0;
IPC1bits.T1IP = 7;
IEC0bits.T1IE = 1;
INTCONbits.MVEC = 1;
__builtin_enable_interrupts();
}
void Motor_Forward(){
LATDbits.LATD6 = 1;
LATDbits.LATD7 = 0;
OC2RS = 500;
OC3RS = 500;
}
void Stop_Motion(){
OC2RS = 0;
OC3RS = 0;
}
void Turning(int speed, int direction){
LATDbits.LATD6 = direction;
LATDbits.LATD7 = direction;
OC2RS = speed;
OC3RS = speed;
}
void Turn1(int speed, int direction)
{
LATDbits.LATD6 = direction;
LATDbits.LATD7 = direction;
OC2RS = 0;
OC3RS = speed;
}
void Motor_Backward(){

10. LATDbits.LATD6 = 0;
LATDbits.LATD7 = 1;
OC2RS = 500;
OC3RS = 500;
}
void Search_Mode()
{
int i = 0;
for (i=0;i<4;i++)
{
TMR3 = 0;
while (TMR3 < 0xFFFF)
{
if (PORTGbits.RG12 == 0 || PORTGbits.RG13 ==0 || PORTGbits.RG14 == 0|| PORTGbits.RG15 == 0 || mode
== Stop)
{
Stop_Motion();
mode= Track;
break;
}
Motor_Forward();
}
TMR3 = 0;
while (TMR3 < 0xffff)
{
if (PORTGbits.RG12 == 0 || PORTGbits.RG13 ==0 || PORTGbits.RG14 == 0|| PORTGbits.RG15 == 0 || mode
== Stop)
{
Stop_Motion();
mode= Track;
break;
}
Motor_Backward();
}
TMR3 = 0;
while (TMR3 < 0xffff)
{
if (PORTGbits.RG12 == 0 || PORTGbits.RG13 ==0 || PORTGbits.RG14 == 0|| PORTGbits.RG15 == 0 || mode
== Stop)
{
Stop_Motion();
mode= Track;

11. break;
}
Turning(300, 1);
}
}
}
void Track_Mode()
{
unsigned int SR; //variable for sensor reading
SR = PORTG & 0xF000;
if (SR == 0x2000 || SR == 0x4000 || SR == 0x6000 || SR == 0x9000) //straight
{
Motor_Forward();
}
else if (SR == 0xA000 || SR == 0xC000 || SR == 0xD000 || SR == 0xE000) //soft right
{
Turning(350, 0);
}
else if (SR == 0x3000 || SR == 0x5000 || SR == 0x7000 || SR == 0xB000) //soft left
{
Turning(350, 1);
}
else if (SR == 0x8000) //hard right
{
Turn1(700, 1);
}
else if (SR == 0x1000 || SR == 0x0000) //hard right
{
Turning(700, 1);
}
else
{
Stop_Motion();
}
}
//PORTGbits.RG12 == 0 && PORTGbits.RG13 == 0 && PORTGbits.RG14 == 0 && PORTGbits.RG15 == 0
//PORTGbits.RG12 != 0 && PORTGbits.RG13 != 0 && PORTGbits.RG14 != 0 && PORTGbits.RG15 != 0
void __ISR (_TIMER_1_VECTOR, IPL7SOFT) T1Interrupt(void){
unsigned int SR;
SR = PORTG & 0xF000;
if (PORTAbits.RA7 == 1)
{

12. mode = Stop;
}
if (mode == Stop && PORTAbits.RA6 == 1)
{
mode = Search;
}
else if (SR == 0xF000 && mode == Track)
{
mode = Search;
}
else if (SR != 0xF000 && mode == Search)
{
mode = Track;
}
IFS0bits.T1IF = 0;
}