Anthony Spinuzza - University of Florida



Anthony Spinuzza

“Algernon” – A Maze Mapping and Navigating Robot

Table of Contents

Abstract 3

Executive Summary 4

Introduction 6

Mobile Platform 6

Actuation 6

Sensors 7

Behaviors 10

Experimental Layout and Results 11

Conclusion 14

Appendix A 15

Appendix B 20

Appendix C 25

Abstract

Algernon is a robot that will navigate a maze and map it as he travels. As he travels through the maze, he measures how far he has traveled, and displays this information on a simple LED display.

Executive Summary

Algernon is a robot based on a TJ Pro that is acts as rat in a maze. It navigates through a maze and determines how far it has traveled. Two hacked servos in the standard TJ Pro arrangement are used for actuation. The 68HC11 Microprocessor on an MTJPRO11 board is used to control the robot. Algernon sensors are comprised of three IR sensors, four bump switches, and a hacked mouse. One IR is placed in front, and one on each side. These are used to determine if a wall is present, and how far away the wall is. This information is then used to decide where the robot should turn. The robot follows a right wall following program. As the robot moves, the mouse measures the distance traveled. This is placed at the rear of the robot. The x-axis control from the mouse is wired to the pulse accumulator system on the HC6811. Algernon is also equipped with the standard bump switches, which let it know if it has hit a wall, so it can back up and try again. As the robot travels, the mouse is moved and the pulse accumulator overflows. These overflows are then counted to determine the distance traveled. This information is the output to a 7-segment LED display. This display counts from 0 to 9, then repeats.

The original intention was for the robot to not only measure how far it had traveled through the maze, but also make a rough map of the maze and chart it as it traveled. Then it would go through the maze a second time and skip the loops and dead ends, heading directly for the exit. The maze we constructed was too small for the IR sensors, so I had to place an extra 1k resistor in order to dim the side IR LED’s to where the sensors could see the walls. This created a difficulty in that it could only see walls nearby, and if extremely off course (i.e. close to the left hand wall) would think that there was no right-hand wall and would try to turn. My original programming approach was to travel down the corridors while remaining centered, and turning when necessary. Since it sometimes didn’t see the walls if it drifted off course - which would usually happen right after turns - it would turn randomly, so I had to change to a right wall follow routine. This made mapping much more difficult, and I did not have sufficient time to complete a mapping program with this algorithm.

Introduction

Algernon is a simple, inexpensive, maze navigation robot. The hardware of Algernon is not much beyond that of a standard TJ Pro robot, augmented with an extra IR sensor and a distance-measuring sensor. Several navigation algorithms were attempted, but the most effective one was a right wall following routine.

Mobile Platform

For a maze-mapping robot, there are no special needs for the platform. A rolling robot is easier to make, so it is a better design. A small robot is also desirable, so then he can navigate in smaller spaces, which allows for a smaller maze passages. With smaller passages, a more complex maze can be constructed in the same amount of space. Algernon is comprised of a TJ Pro body. This body is small in size and has high mobility even in narrow spaces.

Actuation

The only actuation required by Algernon is to navigate through the maze. The motors only need to move the platform, which does not weigh very much, so the standard hacked servos that are used with the Talrik Junior body are sufficient. The standard TJ Pro motor drivers are used.

Sensors

Algernon has two needs for sensors. The first need is to locate walls and determine their distance. The second need is to determine how far he has traveled so the maze can be mapped. To meet the first needs, Infrared sensors are used. For the second need, a mouse was hacked so that the distance traveled straight ahead could be measured.

Bump Sensors

The Talkrik Junior body has a circular main platform that has a detached ring around it. When the robot hits the wall, this ring presses buttons on the main platform, which then lets the robot know that it has hit something.

Infrared Sensors

On the Talrik Junior body, there are two infrared emitters. There are also two detectors that detect the amount of infrared radiation in the area. When there is an object nearby, it usually reflects the infrared radiation from the emitters back to the detectors. When the detectors return a high reading, the robot knows something is nearby. However, dark colors absorb most light and reflect little, so sometimes when the robot is near a black object, it will not detect the obstacle.

Distance Sensor

A hacked mouse was used as a distance sensor. I used a standard PS/2 mouse that I purchased for $10 in Walmart. The x-axis detector of the mouse was connected to the pulse accumulator of the 68HC11. The mouse requires +5V and ground in order to operate properly. To determine which wires were power and ground, I did a continuity test to determine which wire corresponded to which pin on the PS/2 adapter.

Pinout – 1:Unused; 2:+5V; 3:Unused; 4:Clock; 5:Ground; 6:Data

The output from the x-axis detector ranged from 0V to 1.9V, so a circuit was required to amplify and clean up the signal before being sent to the microprocessor. A Schmitt Trigger (74’14) was used to accomplish this. Since the output was about 2V, the trigger needed an input voltage of about 3V. An LM371 variable voltage regulator was used to generate the 3V. In order to build this circuit, a 150 ohm resistor, 100 ohm resistor, .1uF capacitor, and 1uF capacitor were needed. The 74’14 also inverts the signal, but since I’m counting pulses, the direction of the pulse is not important.

Circuit used to amplify mouse signal

In order to use this information, I used the pulse accumulator overflow interrupt. In order to use this interrupt, I had to move the motors from PA7 to PA4, so I had to modify motortjp.c and isrdecl.h. The code for the interrupt is included in the main code in Appendix A. The modified files are found in appendix C.

Originally I intended to interface to the mouse as a PC does. While attempting to get this interface working with the 6811, I accidentally ruined my first mouse. I’m not sure what happened to it, but it no longer worked. So I had to use this method as I was running out of time and had to move on to the programming aspect of the robot.

Seven Segment LED Display

In order to display the distance information, I added an LED display. I purchased this from Radio Shack for about $2. I used seven input pins on the display, which allow me to display all of the numbers from 0 to 9. In order to turn these on and off, I needed to add an output port to my board. I did this at the last minute, so instead of being mounted, it is free hanging off the back of Algernon. It rests on the mouse. I wire wrapped the data bus to the inputs of a 74’574, and used the Y2 enable pin as the enable to the latch. I then use this port, memory mapped to $5000, to control the LED Display.

Behaviors

Algernon has one main behavior – navigating through the maze. This behavior consists of a right wall follow routine which continues until there is an obstacle in front of the robot. At this point, if there is no wall to the left, Algernon turns to the left. If there is a wall to the left, Algernon turns approximately 180 degrees, and starts right wall following again. While he is traveling, he is also measuring how far he has traveled, and updating a 7-segment LED display with a number representing the distance.

I also wrote two different algorithms for navigating the maze. In the first, the robot would travel straight until a turn was needed. Then, the mouse was used to determine when the turn was completed. Using this algorithm, the robot moved much smoother than the algorithm I decided to use. The downfall was that after three or four turns, it would be far enough off course to where it would make a turn where it wasn’t supposed to because it was facing the wrong direction and therefore had erroneous sensor readings.

The second algorithm was a variation on the previous one. In addition to that, it had a straightening algorithm that it used to try to center itself between the two walls and straighten itself up after every turn. This one however ran into the same problems. Usually, the corridors were not long enough to straighten out the robot, and after some turns, there is only one wall. This makes it even harder to straighten out. This algorithm ran into the same problems as the one before, but since it was changing its direction to try to go straight, it usually was further off than the first one.

Experimental Layout and Results

Infrared Sensors

I did a simple test to determine the output range of the IR sensors. The minimum value when there was no object present was 87, and the maximum value when there was a white wall as close as possible without cutting off the light was 127. This was constant for all three of my IR detectors.

Due to the small size of the maze, I had to place 1k( resistors in series with the side IR LED’s in addition to what is built on to the board. This allowed Algernon to detect the side walls even though they were extremely close. However, this also made it so that Algernon could not see some walls that should have been able to be seen.

Maze Readings

I wrote a simple program that the robot navigated the maze and kept a record of all of its sensor readings. For versions of the code including the turn routines, it added a special entry in the table saying that the robot turned left or right or 180 degrees. I used this program to determine the thresholds of whether or not there was a wall to the side of the robot. Algernon would continue to take sensor readings until either the front bumper was hit or sometimes when he detected a wall in front of him, depending on which version of the code I was using. Once Algernon detected one of these conditions, he would stop and wait for the back bumper to be pressed. When the back bumper was pressed, he would transmit the information through the serial port to the computer. I wrote several versions of this code. The code for going in a straight line until a wall is in front of Algernon is included in Appendix B.

Turn Algorithms

For this, I wrote two programs. One was based on my previous turn algorithm, which turned the motors on for a specified amount of time. I turned on the pulse accumulator and ran my old turn routine, recording how many overflows occurred at each stage. Then I printed this information to the computer through the serial port. When the turn was about 90 degrees, I recorded the information in a table, so I could use it to determine a good number to use for letting the mouse control the turns. Total Pulses signifies the total number of pulses received since starting the code. Pulses gives the total pulses for that stage only. Overflows give me a value that is more usable, since I have to set number of overflows first, then I can set PACNT to a suitable value for the remainder.

| |Total Pulses |Pulses |Overflows |

|Straight Before |437 |437 |1.71 |

|Turn |845 |408 |1.60 |

|Straight After |1230 |385 |1.51 |

| | | | |

|Straight Before |643 |643 |2.52 |

|Turn |1051 |408 |1.60 |

|Straight After |1463 |412 |1.62 |

| | | | |

|Straight Before |447 |447 |1.75 |

|Turn |833 |386 |1.51 |

|Straight After |1266 |433 |1.70 |

Another program was written where Algernon turned one motor full on and turned the other off to accomplish a turn. They would remain on for a certain amount of pulses and overflows of the mouse, instead of being based on time. Using this method, more accurate 90 degrees turns could be made. They would usually be within 5 degrees. Starting with values obtained in the first program, I tried sample values in this code until I found the value that worked best. The value I found that worked best for the turning was 1 full overflow, then setting PACNT to $40, and letting it overflow again. This value worked for both right and left turns.

Conclusion

I was able to construct a robot by building a TJ Pro and adding a few features to it. This robot was suitable for most of my needs in a navigation robot. There are a few things that I wish I had been able to accomplish that did not get done. Originally, Algernon was supposed to navigate a maze and remember the best path. I think if more time were spent working on programming, this would be a realizable goal with Algernon. Another feature that I was not able to fully implement was the mouse. I was only able to get x-axis information. I originally intended to interface to the mouse the way a PC does, and get both the x and y direction information, but the direction as well. This should also be possible to do with a little more work.

Appendix A

/*************************** Includes ********************************/

#include

#include

/************************ End of Includes ****************************/

/*************************** Constants ********************************/

#define AVOID_THRESHOLD 100

#define IR_MAX 126

#define IR_MIN 88

#define MAX_RIGHT 75

#define MAX_LEFT 100

#define AMOUNT 300

#define DELAY_TIME 25

#define STOP 123

#define NOWALL 90

#define WALL 105

#define STRAIGHT_DELAY 550

#define TURN_DELAY 850

#define TURN_AROUND_DELAY 800

#define DISPLAY *(unsigned char *)(0x5000)

/************************ End of Constants ****************************/

#pragma interrupt_handler PAV_isr

/*************************** Prototypes *********************************/

void init_PA(void);

void PAV_isr(void);

void TURN_RIGHT(void);

void TURN_LEFT(void);

void TURN_AROUND(void);

/************************ End of Prototypes *****************************/

int speedr, speedl;

int smallcounter, bigcounter;

/* Constants for LED output*/

int NUMBERS[10]={0x7D,0X30,0X6E,0X7A,0X33,0X5B,0X1F,0X70,0X7F,0X73};

void main(void)

/****************************** Main ***********************************/

{

int irdr, irdl, irdc;

int done;

int diff;

init_analog();

init_motortjp();

init_clocktjp();

init_PA();

IRE_ON;

speedr = MAX_RIGHT;

speedl = MAX_LEFT;

done=0;

smallcounter=0;

bigcounter=0;

START;

while(1)

{

speedr=MAX_RIGHT;

speedl=MAX_LEFT;

irdr=RIGHT_IR;

irdl=LEFT_IR;

irdc=CENTER_IR;

//Adjust speed if not close enough to wall

if(irdr >= WALL)

{

diff = irdr - WALL;

if(diff >= 1)

{

speedl = MAX_LEFT - 25;

}

if(diff >= 2)

{

speedl = MAX_LEFT - 40;

}

if(diff >= 4)

{

speedl = MAX_LEFT - 75;

}

if(diff >= 6)

{

speedl = MAX_LEFT - 90;

}

}

else

{

diff = WALL - irdr;

if(diff >= 1)

{

speedr = MAX_RIGHT - 25;

}

if(diff >= 2)

{

speedr = MAX_RIGHT - 35;

}

if(diff >= 4)

{

speedr = MAX_RIGHT - 55;

}

if(diff >= 6)

{

speedr = MAX_RIGHT - 70;

}

}

//if wall on all sides, turn around;

if ((irdc >= STOP) & (irdr >= WALL) & (irdl >= WALL))

{

TURN_AROUND();

}

if((irdr < IR_MIN+1) & (irdc < IR_MIN+1) & (irdl < IR_MIN+1))

{

motorp(RIGHT_MOTOR,0);

motorp(LEFT_MOTOR,0);

speedr=MAX_RIGHT;

speedl=MAX_LEFT;

START;

}

//Back up if hit wall

if(FRONT_BUMP)

{

speedr=-MAX_RIGHT;

speedl=-MAX_LEFT;

motorp(RIGHT_MOTOR, speedr);

motorp(LEFT_MOTOR, speedl);

wait(5 * DELAY_TIME);

}

motorp(RIGHT_MOTOR, speedr);

motorp(LEFT_MOTOR, speedl);

wait(DELAY_TIME);

}

}

void PAV_isr(void)

{

CLEAR_FLAG(TFLG2, 0x20);

smallcounter++;

if(smallcounter==3)

{

smallcounter=0;

bigcounter++;

if(bigcounter > 9)

{

bigcounter=0;

}

DISPLAY=NUMBERS[bigcounter];

}

}

void init_PA(void)

{

INTR_OFF();

CLEAR_BIT(PACTL, 0xB0); /*Set for input, counting, and catch falling edges*/

SET_BIT(PACTL, 0x40); /*Enable PA*/

CLEAR_FLAG(TFLG2, 0x20); /* Clear flag */

SET_BIT(TMSK2, 0x20); /* Enable PA Overflow interrupt */

PACNT=0x00;

INTR_ON();

}

void TURN_AROUND(void)

{

//turn back away from wall

if(RIGHT_IR > LEFT_IR)

{

speedl=MAX_LEFT;

speedr=-MAX_RIGHT;

}

else

{

speedl=-MAX_LEFT;

speedr=MAX_RIGHT;

}

motorp(RIGHT_MOTOR, speedr);

motorp(LEFT_MOTOR, speedl);

wait(TURN_AROUND_DELAY);

speedr = MAX_RIGHT;

speedl = MAX_LEFT;

}

Appendix B

/*************************** Includes ********************************/

#include

#include

/************************ End of Includes ****************************/

/*************************** Constants ********************************/

#define AVOID_THRESHOLD 100

#define IR_MAX 126

#define IR_MIN 88

#define MAX_RIGHT 75

#define MAX_LEFT 100

#define AMOUNT 40

#define DELAY_TIME 25

#define STOP 123

#define NOWALL 95

#define TURN 34

#define TABLE_LENGTH 200

/************************ End of Constants ****************************/

#pragma interrupt_handler PAV_isr

/*************************** Prototypes *********************************/

void init_PA(void);

void PAV_isr(void);

void TURN_RIGHT(void);

void TURN_LEFT(void);

void TURN_AROUND(void);

/************************ End of Prototypes *****************************/

int counter;

int speedr;

int speedl;

void main(void)

/****************************** Main ***********************************/

{

int irdr, irdl, irdc;

int std;

int speedr, speedl;

int diff, lastdiff, change;

int right[TABLE_LENGTH];

int left[TABLE_LENGTH];

int center[TABLE_LENGTH];

int counter, maxcounter;

init_analog();

init_motortjp();

init_clocktjp();

IRE_ON;

speedr = MAX_RIGHT;

speedl = MAX_LEFT;

counter=0;

START;

while(1)

{

irdr=RIGHT_IR;

irdl=LEFT_IR;

irdc=CENTER_IR;

left[counter]=irdl;

center[counter]=irdc;

right[counter]=irdr;

counter=counter+1;

if ((counter == TABLE_LENGTH) | (irdc > 122))

{

motorp(RIGHT_MOTOR, 0);

motorp(LEFT_MOTOR, 0);

maxcounter=counter;

counter=0;

while(1)

{

START;

while(counter irdl)

{

diff = ((irdr - irdl) * AMOUNT) / (IR_MAX - std);

speedl = MAX_LEFT - diff;

}

if (irdl > irdr)

{

diff = ((irdl - irdr) * AMOUNT) / (IR_MAX - std);

speedr = MAX_RIGHT - diff;

}

motorp(RIGHT_MOTOR, speedr);

motorp(LEFT_MOTOR, speedl);

wait(50);

}

}

void PAV_isr(void)

{

counter=counter+1;

if (counter==10)

{

speedr=0;

speedl=0;

}

CLEAR_FLAG(TFLG2, 0x20);

}

void init_PA(void)

{

INTR_OFF();

CLEAR_BIT(PACTL, 0xB0); /*Set for input, counting, and catch falling edges*/

SET_BIT(PACTL, 0x40); /*Enable PA*/

CLEAR_FLAG(TFLG2, 0x20); /* Clear flag */

SET_BIT(TMSK2, 0x20); /* Enable PA Overflow interrupt */

PACNT=0x00;

INTR_ON();

}

void TURN_RIGHT(void)

{

motorp(RIGHT_MOTOR, MAX_RIGHT);

motorp(LEFT_MOTOR, MAX_LEFT);

wait(TURN*DELAY_TIME);

motorp(RIGHT_MOTOR, 0);

motorp(LEFT_MOTOR, MAX_LEFT);

wait(TURN * DELAY_TIME);

motorp(RIGHT_MOTOR, MAX_RIGHT);

motorp(LEFT_MOTOR, MAX_LEFT);

wait(2 * TURN * DELAY_TIME);

speedr=MAX_RIGHT;

speedl=MAX_LEFT;

}

void TURN_LEFT(void)

{

motorp(RIGHT_MOTOR, MAX_RIGHT);

motorp(LEFT_MOTOR, MAX_LEFT);

wait(TURN*DELAY_TIME);

motorp(RIGHT_MOTOR, MAX_RIGHT);

motorp(LEFT_MOTOR, 0);

wait(TURN * DELAY_TIME);

motorp(RIGHT_MOTOR, MAX_RIGHT);

motorp(LEFT_MOTOR, MAX_LEFT);

wait(2 * TURN * DELAY_TIME);

speedr=MAX_RIGHT;

speedl=MAX_LEFT;

}

void TURN_AROUND(void)

{

motorp(RIGHT_MOTOR, -MAX_RIGHT);

motorp(LEFT_MOTOR, MAX_LEFT);

wait((TURN - 4) * DELAY_TIME);

speedr = MAX_RIGHT;

speedl = MAX_LEFT;

}

Appendix C

a) Motortjp.c

/**********************************************************************

* MEKATRONIX Copyright 1998 *

* Title motortjp.c (Motor Drivers for TJ Pro) *

* Programmer Drew Bagnell modified TJ drivers *

* Date December, 1997 *

* Version 1 *

* Version 1.1 by Keith L. Doty

Changed some names, set PACTL bits with one command, cleaned up.

* *

* Description *

* Version History: These drivers follow Mechantronix TJP standard: *

* left motor is motor 0 (PA4) and right motor is motor 1 (PA3). *

* For efficient use of output compares, OC5 is used to modulated pins*

* both PA3 and PA4. Changes were made to setup to allow drivers to *

* work with both A and E series MC68HC11 chips. *

**********************************************************************/

/**************************** Includes **********************************/

#include

#include

/************************************************************************/

/**************************** Constants *********************************/

#define HALFPERIOD 20000 /* 50Hz refresh for each motor */

#define MIN_PWM 2200

#define MAX_PWM 3800

#define SPEED_SLOPE 8 /* modified for TJP */

#define SPEED_INT 3000

#define motortjp_hand TOC5_isr

/************************************************************************/

/*************************** Prototypes *********************************/

#pragma interrupt_handler TOC5_isr

void init_motortjp(void);

void motorp(int, int);

void motortjp_hand();

/************************************************************************/

/***************************** Globals **********************************/

unsigned int width[2]; /* width[] is the on-time for each motor*/

unsigned int current_width;

char signal_state, motormask[2];

/************************************************************************/

void

init_motortjp(void)

/************************************************************************

* Function: Initializes all necessary variables for the motors. *

* Returns: None *

* *

* Inputs *

* Parameters: None *

* Globals: None *

* Registers: None *

* Outputs *

* Parameters: None *

* Globals: width[], signal_state, motormask[], current_width *

* Registers: TOC2, PORTB, TMSK1, TCTL1 *

* Functions called: None *

* Notes: None *

************************************************************************/

{

INTR_OFF();

CLEAR_BIT(TCTL1,0x03); /* Interrupt will not affect OC5 pin */

width[0] = width[1] = 0; /* Motors start turned off */

TOC5 = 0;

signal_state = 0;

current_width = 0;

motormask[0] = 0x10; /* Drives PA4, left motor*/

motormask[1] = 0x08; /* Drives PA3, right motor*/

/* PA gates on (TJP specific) */

/* Set PA3 (OC5) to output */

SET_BIT(PACTL,0x08);

SET_BIT(TMSK1,0x08); /* Enable OC5 interrupt */

INTR_ON();

}/*end init_motortjp*/

The remainder of the file is unmodified

b) isrdecl.h

/**********************************************************************

* Title isrdecl.h *

* Programmer Keith L. Doty *

* Date September 16, 1998 *

* Version 1.1 with servo driver *

* *

* Description *

* This file declares nil functions for all the undeclared *

* interrupt service routines. If you define a new handler, its *

* ISR name must appear in a #define below in order to bypass the*

* conditional compile that will force it to be a null function. *

* *

* Version History: *

* *

**********************************************************************/

/*

The following list of #defines lists the currently used interrupt

service routines.

*/

/* TJ Pro timer/clock handler */

#define TOC1_isr

/* TJ Pro Motor handler */

#define TOC5_isr

/*

ISR names not listed above as a #define will be compiled to a null

function in the conditional compilation below.

*/

#ifndef SCI_isr

#pragma interrupt_handler SCI_isr;

void SCI_isr()

{/* Nil Function Declaration */}

#endif

#ifndef SPI_isr

#pragma interrupt_handler SPI_isr;

void SPI_isr()

{/* Nil Function Declaration */}

#endif

#ifndef PAIE_isr

#pragma interrupt_handler PAIE_isr;

void PAIE_isr()

{/* Nil Function Declaration */}

#endif

#ifndef TOF_isr

#pragma interrupt_handler TOF_isr;

void TOF_isr()

{/* Nil Function Declaration */}

#endif

#ifndef TOC5_isr

#pragma interrupt_handler TOC5_isr;

void TOC5_isr()

{/* Nil Function Declaration */}

#endif

#ifndef TOC4_isr

#pragma interrupt_handler TOC4_isr;

void TOC4_isr()

{/* Nil Function Declaration */}

#endif

#ifndef TOC2_isr

#pragma interrupt_handler TOC2_isr;

void TOC2_isr()

{/* Nil Function Declaration */} /* Controls PWM of wheel motors */

#endif

#ifndef TOC3_isr

#pragma interrupt_handler TOC3_isr;

void TOC3_isr()

{/* Nil Function Declaration */} /* IR detector service routine */

#endif

#ifndef TOC1_isr

#pragma interrupt_handler TOC1_isr;

void TOC1_isr()

{/* Nil Function Declaration */}

#endif

#ifndef TIC3_isr

#pragma interrupt_handler TIC3_isr;

void TIC3_isr()

{/* Nil Function Declaration */}

#endif

#ifndef TIC2_isr

#pragma interrupt_handler TIC2_isr;

void TIC2_isr()

{/* Nil Function Declaration */}

#endif

#ifndef TIC1_isr

#pragma interrupt_handler TIC1_isr;

void TIC1_isr()

{/* Nil Function Declaration */}

#endif

#ifndef RTI_isr

#pragma interrupt_handler RTI_isr;

void RTI_isr()

{/* Nil Function Declaration */}

#endif

#ifndef IRQ_isr

#pragma interrupt_handler IRQ_isr;

void IRQ_isr()

{/* Nil Function Declaration */}

#endif

#ifndef XIRQ_isr

#pragma interrupt_handler XIRQ_isr;

void XIRQ_isr()

{/* Nil Function Declaration */}

#endif

#ifndef SWI_isr

#pragma interrupt_handler SWI_isr;

void SWI_isr()

{/* Nil Function Declaration */}

#endif

#ifndef ILLOP_isr

#pragma interrupt_handler ILLOP_isr;

void ILLOP_isr()

{/* Nil Function Declaration */}

#endif

#ifndef COP_isr

#pragma interrupt_handler COP_isr;

void COP_isr()

{/* Nil Function Declaration */}

#endif

#ifndef CLMON_isr

#pragma interrupt_handler CLMON_isr;

void CLMON_isr()

{/* Nil Function Declaration */}

#endif

................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download