How to make a
GPS-based autopilot
control head
for your boat

Overview

1. Get the autopilot repaired by the manufacturer.
   
   Likely to be expensive, if feasible at all. And afterward I'll have a repaired 35-year-old autopilot.
   
   
2. Buy a complete new modern below-decks hydraulic autopilot.
   
   Expensive; probably $2000 ?
   
   
3. It might be possible to buy just the control head part (compass and buttons and intelligence electronics) of a modern autopilot and connect that to the "movement" parts of my old autopilot. The control head itself would cost $100-$200 used, maybe $400 new, and then a small dab of additional electrical stuff might be needed to connect it to my existing electrical motor.
   
   
4. Make a full control head:
   
   Design and make a small circuit board containing a magnetic or fluxgate compass sensor or a GPS module, and control relays that can control the electric motor of my autopilot. I could design it simply to keep steering in whatever direction the boat was headed when the board was turned on, so it wouldn't need any kind of "user interface" (buttons and LEDs and display to let the user control it). Total parts cost might be $150-$300.
   
   But my circuit-design and circuit-building skills are nil. This also requires computer-programming skills; I have those.
   
   
5. Connect GPS to "movement" parts of my old autopilot.
   
   I already have a GPS that can output NMEA 0183 information to steer to a waypoint. That is most of the "intelligence" of an autopilot control head; maybe I can connect that to the "movement" parts of the old autopilot.
   
   What is needed is some electronics that can read NMEA 0183 signals from the GPS and produce "steer right" and "steer left" electrical outputs to the electrical motor from my old autopilot.
   
   

1. Commercial products:
   
   I have found one cheap-ish commercial product that connects GPS to steering: the GPS Smart Coupler.
   
   But it costs $250, and the output signals from it won't control an electrical motor directly (without some additional relays or other electrical stuff). And things could get complicated if the "steering sensitivity" of the two parts don't match.
   
   
2. Make it myself:
   
   I could buy and program a small circuit board that will read NMEA 0183 output from my boat's GPS and control relays that can control the electric motor of my autopilot. Total parts cost might be $100.
   
   This requires computer-programming skills; I have those.
   
   

Parts

1. GPS that can steer to a waypoint and output NMEA sentences.
   
   Looks like the GPS must output the "GPRMB" sentence, which contains the "cross-track error" info.
   Example: $GPRMB,A,0.66,L,003,004,4917.24,N,12309.57,W,001.3,052.5,000.5,V*0B<CR><LF>
   where "0.66,L" (always exactly 6 digits) is the cross-track error in NM and direction to steer.
   
   My boat has a Garmin 128 GPS, which can do this.
   (Some GPS's may provide a "GPAPB" or "GPXTE" sentence instead, which gives same "cross-track error" info. Some GPS's may provide proprietary sentences, starting with "P", to do the same.)
   
   Not sure how often these sentences are output by each GPS.
   
   Not sure what the Data Status (A/V) field means; one document says "A = OK, V = warning", another says "A = OK, V = Void (warning)", another says "A = Active, V = Void". Does that mean "A = on course, V = off course", "A = good info, V = ignore this sentence", or something else ?
   
   GPS NMEA 0183 output (RS-232) must be +/-12 volts; I've heard some (non-GPS) devices cheat and put out +/-5 volts.
   [VERIFY THAT MY GPS'S NMEA OUTPUT LEVEL IS +/-12 VOLTS; MANUAL DOESN'T SAY.]
   
   
   
2. Circuit board (development board) that can read NMEA 0183 (RS-232) input and control relays for motor-control.
   
   I chose to use PIC-based boards, and bought this one:
   Microchip PIC-IO-A or PIC-IO-18 ($33; 18-pin; 4 x 10A relays)
   
   (I think my autopilot motor draws about 5A at 12VDC, well within the relay capacity. And I can gang together two relays for each steering direction, so I'd be using only 5A of a 20A capacity. My old autopilot does have a relay box for the motor, but it's fairly complicated and I'm not sure I want to rely on it.)
   
   12V input
   Status LED connected to RB5 (PORTB bit 5; marked "LED9" on board)
   Input status LEDs (marked "LED1" through "LED4" on board; RA4 = LED1/IN1, RB0 = LED2/IN2, RB3 = LED3/IN3, RB4 = LED4/IN4)
   Output/relay status LEDs (marked "LED5" through "LED8" on board; RA3 = LED5/RELAY1, RA2 = LED6/RELAY2, RA1 = LED7/RELAY3, RA0 = LED8/RELAY4)
   (Had to get the schematic image for the board to figure out the pin-to-LED assignments.)
   
   
   
3. Microcontroller chip to plug into the circuit board:
   
   I chose PIC-type processors:
   (Must have one with a UART or USART, for doing RS-232.)
   (Not sure what memory size I'm going to need.)
   
   Wanted SparkFun PIC 16F88 (4K; $5), but ended up buying everything from Microchip, so got:
   PIC16F628A-I/P from Microchip (2K; $3; 18 DIP; 20 MHz)
   
   
   
4. A PC (desktop or laptop) for writing and downloading the program that will run on the processor chip:
   
   I have a laptop with a USB port, no RS-232 port.
   This turns out to be important when you get to the "choose a programmer" step; programmers using USB are more expensive than those using RS-232, but laptop RS-232 ports or USB-to-RS-232 adapters may not work.
   
   
5. Software to create the program that will run on the processor chip:
   
   I chose to write in the C language, so I need a C compiler that supports the chip I chose:
   HI-TECH C PRO for the PIC10/12/16 MCU Family (free)
   MPLAB Integrated Development Environment (free; includes debugger, simulator, two C compilers, interfaces to programmer boards)
   [DO I WANT TO TRY A SIMULATOR ?]
   
   
6. Programmer board to install program from PC into PIC processor chip:
   
   (Programmers vary by: chips supported, type of connection to PC, type of power source, type of connection to chip or development board.)
   
   SparkFun PGM-00004 ($92; USB)
   Futurlec ($59; USB)
   
   I bought the Microchip PX-200.
   
   Had to buy special cable to connect programmer to development board; apparently there are no standards, so cable that came with programmer wasn't right. Cable cost $9.50 plus $4 shipping. Use beige RS232 cable, not grey one, and pins are connected as follows: MCLR on small board to pin 1 on PIC-IO-18 board, rest in order up to PGM on small board to pin 6 on PIC-IO-18 board.
   
   
7. Software to drive programmer board:
   
   PICkit 2 came included with the programmer board, and is used by MPLAB IDE.
   
   IC-Prog (free)
   [DON'T SEE ANY OF THE USB PROGRAMMERS ABOVE ON THE IC-PROG SUPPORTED LIST]
   
   
   
8. Miscellaneous:
   
   Male DB-9 connector to plug into circuit board, for NEMA input from GPS.
   Various wire.
   12V power plug to fit socket on target board.
   Power switch.
   Box to mount/hold/shield the circuit board.
   
   
   

• PIC knowledge:
  
  SparkFun
  MicrochipC
  MicrochipC's "PIC and Hi-Tech C FAQ"
  MicroController Pros' "Developing Embedded Systems - A Tools Introduction"
  Wikipedia's "PIC microcontroller"
  PICList
  
  
  
• PIC parts:
  
  SparkFun
  MicroControllerShop
  MicrochipC
  
  
  
• NMEA knowledge:
  
  from Dale DePriest
  NMEA signals are RS-232 at 4800 bps, no parity, and one stop bit.
  
  
  

Test Programming

// Test program to blink LEDs on PIC-IO-18 (PIC-IO-A) board
// with PIC16F628A chip installed.

#include <pic.h>
#include <pic16f62xa.h>
#include <htc.h>	// required for delay routines

__CONFIG(UNPROTECT & LVPDIS & BORDIS & MCLREN & PWRTDIS & WDTDIS & HS);  // 0x3F2A
/* for PIC-IO-18 board, oscillator configuration == HS */

#ifndef _XTAL_FREQ
// required to calibrate __delay_us() and __delay_ms()
#define _XTAL_FREQ 4000000	// internal clock freq (4MHz), not freq (20MHz) of crystal on board
#endif

/*
for PIC-IO-18 board:
	output: RB5 = status LED9
	inputs: RA4 = LED1/IN1, RB0 = LED2/IN2, RB3 = LED3/IN3, RB4 = LED4/IN4
	outputs/relays: RA3 = LED5/RELAY1, RA2 = LED6/RELAY2, RA1 = LED7/RELAY3, RA0 = LED8/RELAY4
*/

main(void)
{
	unsigned int	i;

	TRISA = 0;		// all port A bits output
	TRISB = 0;		// all port B bits output
	PORTA = 0x00;		// turn all outputs off
	PORTB = 0x00;		// turn all outputs off

	for(;;) {
//		RA3 = 1;			// LED5/RELAY1
		RB5 = 1;			// LED9
		for(i = 50 ; --i ;) {
			__delay_ms(20);
		}
		RB5 = 0;			// LED9
		for(i = 500 ; --i ;) {
			__delay_ms(20);
		}
	}
}

// Program to test timer interrupts
// on PIC-IO-18 (PIC-IO-A) board
// with PIC16F628A chip installed.

#include <pic.h>
#include <pic16f62xa.h>

__CONFIG(UNPROTECT & LVPDIS & BORDIS & MCLREN & PWRTDIS & WDTDIS & HS);  // 0x3F2A
/* for PIC-IO-18 board, oscillator configuration == HS */

/*
for PIC-IO-18 board:
	output: RB5 = status LED9
	inputs: RA4 = LED1/IN1, RB0 = LED2/IN2, RB3 = LED3/IN3, RB4 = LED4/IN4
	outputs/relays: RA3 = LED5/RELAY1, RA2 = LED6/RELAY2, RA1 = LED7/RELAY3, RA0 = LED8/RELAY4
*/

static long	lCount0;
static long	lCount1;
static bit	bLED0On;
static bit	bLED1On;

main(void)
{
	TRISA = 0;		// all port A bits output
	TRISB = 0;		// all port B bits output
	PORTA = 0x00;	// turn all outputs off
	PORTB = 0x00;	// turn all outputs off

	lCount0 = 0;
	lCount1 = 0;
	bLED0On = 0;
	bLED1On = 0;

	// Timer 0 is an 8-bit counter that interrupts
	// when it overflows from 0xFF to 0x00.
	// There is an 8-bit "prescaler", which counts
	// how many cycles (0-256) to ignore before incrementing
	// the counter each time.
	// This prescaler is shared with the watchdog timer.
	OPTION = 0b0111;	// Timer 0 prescale by 1:256
	T0CS = 0;		// Timer 0 increments on instruction clock
	T0IE = 1;		// Enable interrupt on TMR0 overflow

	// Timer 1 is a 16-bit counter that interrupts
	// when it overflows from 0xFFFF to 0x0000.
	// There is a 2-bit "prescaler", which counts
	// how many cycles (0-8) to ignore before incrementing
	// the counter each time.
	T1CKPS1 = 0;	// Timer 1 prescale by 1:1
	T1CKPS0 = 0;
	TMR1CS = 0;		// Timer 1 increments on instruction clock
	TMR1IE = 1;		// Enable interrupt on Timer 1 overflow
	TMR1ON = 1;		// Enable Timer 1

	// Timer 2: does not generate interrupts; feeds output
	// to serial port or CCP.

	PEIE = 1;		// enable peripheral interrupts; needed for Timer1
	GIE = 1;		// Global interrupt enable

	for(;;)
		NOP();		// do nothing
}


// interrupt function - the name is unimportant
static void interrupt
isr(void)
{
	// timer 0 overflow ?
	if (T0IF) {
		lCount0++;
		if ((lCount0%32) == 0) {
			bLED0On = !bLED0On;
			RB5 = bLED0On;		// LED9
		}
		T0IF = 0;		// clear interrupt flag, ready for next
	}

	// timer 1 overflow ?
	else if (TMR1IF) {
		lCount1++;
		if ((lCount1%128) == 0) {
			bLED1On = !bLED1On;
			RA3 = bLED1On;		// LED5/RELAY1
		}
		TMR1IF = 0;		// clear interrupt flag, ready for next
	}

	// unexpected interrupt
	else {
		RA0 = 1;			// LED8/RELAY4
	}
}

// Program to test serial port receive interrupts
// on PIC-IO-18 (PIC-IO-A) board
// with PIC16F628A chip installed.

#include <pic.h>
#include <pic16f62xa.h>

__CONFIG(UNPROTECT & LVPDIS & BORDIS & MCLREN & PWRTDIS & WDTDIS & HS);  // 0x3F2A
/* for PIC-IO-18 board, oscillator configuration == HS */

/*
for PIC-IO-18 board:
	output: RB5 = status LED9
	inputs: RA4 = LED1/IN1, RB0 = LED2/IN2, RB3 = LED3/IN3, RB4 = LED4/IN4
	outputs/relays: RA3 = LED5/RELAY1, RA2 = LED6/RELAY2, RA1 = LED7/RELAY3, RA0 = LED8/RELAY4
*/

// do RS232 9600 baud, 8 bits
#define BAUD 9600
#define FOSC 20000000L
#define DIVIDER ((int)(FOSC/(16UL * BAUD) -1))// for >= 9600 baud
//#define DIVIDER ((int)(FOSC/(64UL * BAUD) -1))// for < 9600 baud

static unsigned char cInput;

static long	lCount;
static bit	bLEDOn;

main(void)
{
	unsigned char cInput;

	TRISA = 0;		// all port A bits output
	TRISB = 0;		// all port B bits output
	PORTA = 0x00;	// turn all outputs off
	PORTB = 0x00;	// turn all outputs off

	lCount = 0;
	bLEDOn = 0;

	// initialize communications
	TRISB = 0x06;	// RB1 and RB2 used by USART
	SPBRG = DIVIDER;// set baud rate
	RCSTA = 0x80;	// serial port enable, 8-bit
	TXSTA = 0x04;	// 8-bit, no-xmit, async, high-speed
	RCIE = 1;		// enable recv interrupts
	TXIE = 0;		// no xmit interrupts
	CREN = 1;		// continuous recv enable

	PEIE = 1;		// enable peripheral ints; needed for USART
	GIE = 1;		// Global interrupt enable

	for(;;)
		NOP();		// do nothing
}


// interrupt function - the name is unimportant
static void interrupt
isr(void)
{
	// received char ?
	if (RCIF) {
		if (FERR) {
			// framing error
			unsigned char cGarbage = RCREG;	// clears FERR
			RA1 = 1;		// LED7/RELAY3
			RCIF = 0;
			return;
		}
		lCount++;
		cInput = RCREG;
		if (cInput == 'G') {
			RA3 = 1;		// LED5/RELAY1
			NOP();
			NOP();
			RA3 = 0;		// LED5/RELAY1
		}
		bLEDOn = !bLEDOn;
		RB5 = bLEDOn;		// LED9
		if (OERR) {
			// overrun error
			CREN = 0;
			CREN = 1;
			RA2 = 1;		// LED6/RELAY2
		}
		RCIF = 0;		// clear interrupt flag, ready for next
	}

	// unexpected interrupt
	else {
		RA0 = 1;			// LED8/RELAY4
	}
}

//--------------------------------------------------------------------------
// Test program to read inputs and light LEDs on PIC-IO-18 (PIC-IO-A) board
// with PIC16F628A chip installed.

// At startup, should see LED9 blink and all relays turn on.  Then when
// input voltage is applied to IN1 through IN4, should see corresponding
// input indicator LED light, and corresponding relay de-activate.

// Important: maximum voltage to a single input is 9.6V; otherwise
// you will exceed allowed 20 mA current through LED.

// To use this program with the standard board and no additional
// components (no additional drop-down resistors) in a nominally "12-volt"
// system, you can wire each set of two inputs in series, so that the
// voltage across each input is nominally 6 volts.  Positive goes to
// top of input 1, negative to bottom of input 2, bottom of 1 connected
// to top of 2.  Similarly, positive to top of input 3, negative to bottom
// of input 4, bottom of 3 connected to top of 4.

//--------------------------------------------------------------------------

#include <pic.h>
#include <pic16f62xa.h>
#include <htc.h> // required for delay routines

__CONFIG(UNPROTECT & LVPDIS & BORDIS & MCLREN & PWRTDIS & WDTDIS & HS); // 0x3F2A
/* for PIC-IO-18 board, oscillator configuration == HS */

#ifndef _XTAL_FREQ
// required to calibrate __delay_us() and __delay_ms()
#define _XTAL_FREQ 4000000 // internal clock freq (4MHz), not freq (20MHz) of crystal on board
#endif

/*
for PIC-IO-18 board:
output: RB5 = status LED9
inputs: RA4 = LED1/IN1, RB0 = LED2/IN2, RB3 = LED3/IN3, RB4 = LED4/IN4
outputs/relays: RA3 = LED5/RELAY1, RA2 = LED6/RELAY2, RA1 = LED7/RELAY3, RA0 = LED8/RELAY4
*/

bit bLED9 = 0;

//--------------------------------------------------------------------------

main(void)
{
unsigned int i;

TRISA = 0x10;	// RA4 is input; all other port A bits output
TRISB = 0x19;	// RB0/RB3/RB4 are inputs; all other port B bits output
PORTA = 0x00;	// turn all outputs off
PORTB = 0x00;	// turn all outputs off

for(;;) {

	RB5 = bLED9;
	bLED9 = (!bLED9);

	for(i = 10 ; --i ;) {
		__delay_ms(20);
	}

	// Want to do this:
	//RA3 = RA4;	// RELAY1 = IN1
	//RA2 = RB0;	// RELAY2 = IN2
	//RA1 = RB3;	// RELAY3 = IN3
	//RA0 = RB4;	// RELAY4 = IN4

	// But can't read and write individual bits so quickly; have to gang it up
	unsigned char cPortA;
	unsigned char cPortB;
	unsigned char cNewPortA;
	cPortA = PORTA;
	cPortB = PORTB;
	cNewPortA = 0;
	//RA3 = RA4;	RELAY1 = IN1
	if (cPortA & 0x10)
		cNewPortA |= 0x08;
	//RA2 = RB0;	RELAY2 = IN2
	if (cPortB & 0x01)
		cNewPortA |= 0x04;
	//RA1 = RB3;	RELAY3 = IN3
	if (cPortB & 0x08)
		cNewPortA |= 0x02;
	//RA0 = RB4;	RELAY4 = IN4
	if (cPortB & 0x10)
		cNewPortA |= 0x01;
	PORTA = cNewPortA;
}
}

//--------------------------------------------------------------------------

Programming

//--------------------------------------------------------------------------
// GPS-auto-pilot program on PIC-IO-18 (PIC-IO-A) board
// with PIC16F628A chip installed.

// Connect GPS at 9600 baud to DB9 connector on PIC-IO-18 board.
// Connect relays 1 and 2 to auto-pilot "back-end" (some
// electrically-controlled steering mechanism) in your boat.
// Create a waypoint in the GPS.
// Tell GPS to "go to" the waypoint.
// Auto-pilot should steer to the waypoint.

// Normal operation: at power-up, board's LED9 should turn on for 2.5 secs,
// then should blink on and off as each NMEA sentence is received from GPS.
// While GPS is in goto-waypoint mode, relay 1 or 2 should turn on to
// steer boat back onto course as needed.
// So:
// - If LED9 doesn't turn on at startup, maybe board doesn't have power,
//		or auto-pilot program hasn't been downloaded into board, or board
//		or chip is bad.
// - If LED9 doesn't blink while GPS is on, maybe wiring from GPS to board
//		is wrong, or GPS is not producing NMEA output, or NMEA baud rate
//		doesn't match what the program is expecting.
// - If relays don't come on as boat goes off-course, maybe GPS is not
//		in goto-waypoint mode, or boat is within arrived-at-waypoint distance,
//		or GPS does not produce NMEA $GPRMB sentence that the program is
//		expecting.
// - If relay comes on but boat course does not change, maybe wiring from
//		board relays to your auto-pilot back-end is wrong, or your back-end
//		is not working.
// - If auto-pilot steering sensitivity or aggressiveness is wrong, change
//		STEERING_ON_DURATION, STEERING_AFTER_DURATION, and/or
//		STEERING_BEARING_MINIMUM values, rebuild program, download it to
//		board, and test again.

// Note: program requires just over 1K of program space in processor,
// with LITE compiler.  Supposedly PRO compiler would require half that.
// Could remove some error-checking code to get under the 1K limit.

//--------------------------------------------------------------------------

#include <pic.h>
#include <pic16f62xa.h>

__CONFIG(UNPROTECT & LVPDIS & BORDIS & MCLREN & PWRTDIS & WDTDIS & HS); // 0x3F2A
/* for PIC-IO-18 board, oscillator configuration == HS */

/*
for PIC-IO-18 board:
output: RB5 = status LED9
inputs: RA4 = LED1/IN1, RB0 = LED2/IN2, RB3 = LED3/IN3, RB4 = LED4/IN4
outputs/relays: RA3 = LED5/RELAY1, RA2 = LED6/RELAY2, RA1 = LED7/RELAY3, RA0 = LED8/RELAY4

for auto-pilot application:
RB5/LED9 toggled when character received
RA3/LED5/RELAY1 turned on to steer left
RA2/LED6/RELAY2 turned on to steer right

For my old auto-pilot back-end, need to apply line positive to either
R or L terminal of back-end to effect steering right or left.
Although my particular back-end would tolerate it, want to avoid any possibility
of turning on BOTH at same time (software error could turn on both relays at same time).
In some systems, maybe this could short power to ground and blow something up.
So do wiring to make this software error harmless:
- connect line positive to center post of relay 1.
- connect "on" post of relay 1 to "L".
- connect "off" post of relay 1 to center post of relay 2.
- connect "on" post of relay 2 to "R".
Now relay 2 will not get any connection to positive unless relay 1 is off.
No possibility of both "L" and "R" getting connected to positive even
if both relays get turned on at same time.
*/

//--------------------------------------------------------------------------

// do RS232 9600 baud, 8 bits
#define BAUD 9600
#define FOSC 20000000L
#define DIVIDER ((int)(FOSC/(16UL * BAUD) -1))// for >= 9600 baud
//#define DIVIDER ((int)(FOSC/(64UL * BAUD) -1))// for < 9600 baud

// signal permanent errors by setting relays 3 and 4 ?
// if 1, then don't wire anything to relays 3 and 4 !
#define SIGNAL_PERMANENT_ERRORS_ON_RELAYS_3_AND_4		1

// tweak these parameters to make auto-pilot steering more or less aggressive
// duration of steering in 10 msec units (actually, seems to be more like 12.5 msec units)
#define STEERING_ON_DURATION		250
// duration of after-steering wait in 10 msec units (actually, seems to be more like 12.5 msec units)
// (not sure of maximum value before overflow; tested up to 6000
#define STEERING_AFTER_DURATION		1500
// don't try to correct until GPS says we're at least this many degrees off course
// includes digit after decimal point, so divide by 10 to get degrees from on-track
#define STEERING_BEARING_MINIMUM	50



// sentence from GPS will look like:
// $GPRMB,A,0.66,L,003,004,4917.24,N,12309.57,W,001.3,052.5,000.5,V*0BCRLF
int nNextField = 0;		// NMEA field num; fields are comma-separated
int nNextPosInField = 0;	// char num within field
int nXTError = 0;		// GPS error "n.nn" converted to integer nnn
int nSteerBearing = 0;	// GPS error "n.nn" converted to integer nnn
char cSteerDir = ' ';

// If count>0, we are starting up. Stop when it gets down to 0.
long lStartingCount = 0;
// If count>0, we are steering. Stop steering when it gets down to 0.
long lSteeringCount = 0;
// If count>0, we are waiting after steering. Stop waiting when down to 0.
long lPostSteeringCount = 0;

bit bPermanentFatalError = 0;

bit bLED9On = 0;

//--------------------------------------------------------------------------

main(void)
{
TRISA = 0;		// all port A bits output
TRISB = 0;		// all port B bits output
PORTA = 0x00;	// turn all outputs off
PORTB = 0x00;	// turn all outputs off

lStartingCount = 200;
lSteeringCount = 0;		// not steering
lPostSteeringCount = 0;
bLED9On = 0;

// Timer 0 is an 8-bit counter that interrupts
// when it overflows from 0xFF to 0x00.
// There is an 8-bit "prescaler", which counts
// how many cycles (0-256) to ignore before incrementing
// the counter each time.
// This prescaler is shared with the watchdog timer.
OPTION = 0b0111; // Timer 0 prescale by 1:256
T0CS = 0; // Timer 0 increments on instruction clock
T0IE = 1; // Enable interrupt on TMR0 overflow

// initialize communications
TRISB = 0x06; // RB1 and RB2 used by USART
SPBRG = DIVIDER;// set baud rate
RCSTA = 0x80; // serial port enable, 8-bit
TXSTA = 0x04; // 8-bit, no-xmit, async, high-speed
RCIE = 1; // enable recv interrupts
TXIE = 0; // no xmit interrupts
CREN = 1; // continuous recv enable

RB5 = 1;	 // LED9 on while starting

PEIE = 1; // enable peripheral ints; needed for USART
GIE = 1; // Global interrupt enable

for(;;)
	NOP(); // do nothing forever; action happens in interrupt routine
}

//--------------------------------------------------------------------------

// interrupt function - the name is unimportant
static void interrupt
isr(void)
{
char cInput = ' ';

// timer 0 overflow ?
if (T0IF) {
	if (bPermanentFatalError) {
		T0IF = 0; // clear interrupt flag, ready for next
		return;
	}
	if (lStartingCount > 0) {
		lStartingCount--;
		if (lStartingCount <= 0)
			RB5 = 0;	 // LED9 off after starting
	} else if (lSteeringCount > 0) {
		lSteeringCount--;
		if (lSteeringCount <= 0) {
			// stop steering
			lSteeringCount = 0;
			// don't steer left
			//RA3 = 0; // LED5/RELAY1
			//RA2 = 0; // LED6/RELAY2
			// don't steer right
			//RA1 = 0; // LED7/RELAY3
			//RA0 = 0; // LED8/RELAY4
			//PORTA ^= 0xF0;		// turn off RA0/RA1/RA2/RA3 bits
			PORTA = 0x00;		// turn off RA0/RA1/RA2/RA3 bits
			lPostSteeringCount = STEERING_AFTER_DURATION;
		}
	} else if (lPostSteeringCount > 0) {
		lPostSteeringCount--;
	}
	T0IF = 0; // clear interrupt flag, ready for next
}

// received char ?
else if (RCIF) {
	if (bPermanentFatalError) {
		cInput = RCREG;
		RCIF = 0;
		return;
	}
	if (FERR) {
		// framing error
		cInput = RCREG; 	// clears FERR
		// no way to tell user about problem !!!
		if (lStartingCount == 0) {
			lSteeringCount = 0;
			lPostSteeringCount = 0;
#if SIGNAL_PERMANENT_ERRORS_ON_RELAYS_3_AND_4
			// to signal problem
			PORTA = 0x03;		// turn on RA0/RA1 bits; RELAY4/RELAY3
			bPermanentFatalError = 1;
#endif
		}
		// ignore any partial line recved
		nNextField = 0;
		nNextPosInField = 0;
		RCIF = 0; 		// clear interrupt flag, ready for next char
		return;
	}

	cInput = RCREG;

	if ((lStartingCount == 0) && (cInput == '$')) {
		// toggle LED9 to show that a char was received
		bLED9On = !bLED9On;
		RB5 = bLED9On; // LED9
	}

	// while starting or steering or waiting after steering, ignore GPS output
	if ((lStartingCount > 0) || (lSteeringCount > 0) || (lPostSteeringCount > 0)) {
		cInput = ' ';
		nNextField = 0;
		nNextPosInField = 0;
	}

	// sentence from GPS will look like:
	// $GPRMB,A,0.66,L,003,004,4917.24,N,12309.57,W,001.3,052.5,000.5,V*0BCRLF
	//				 ^----- steer left or right (field 3)
	//			^^^^----- cross-track error (field 2)
	//				(field 11) true bearing to dest ------^^^^^
	//					(field 13) 'A' if within arrival circle ------^
	// 01234567890123456789012345678901234567890123456789012345
	if (nNextField == 0) {
		const char sStart[10] = "$GPRMB";
		if (cInput == sStart[nNextPosInField])
			nNextPosInField++;
		else if (cInput == ',') {
			nNextField++;
			nNextPosInField = 0;
		} else
			// unexpected char; give up
			// nNextField is 0 already
			nNextPosInField = 0;
	}
	else if (nNextField == 1) {
		// Status field
		if ((nNextPosInField == 0) && (cInput == 'A')) {
			// okay
			nNextPosInField++;
		} else if ((nNextPosInField == 1) && (cInput == ',')) {
			nXTError = 0;
			nNextField++;
			nNextPosInField = 0;
		} else {
			// unexpected char; give up
			nNextField = 0;
			nNextPosInField = 0;
		}
	}
	else if (nNextField == 2) {
		// XTK error magnitude
		if ((cInput >= '0') && (cInput <= '9')) {
			nXTError = (nXTError * 10) + (cInput - '0');
		} else if (cInput == '.') {
			// do nothing
		} else if (cInput == ',') {
			nNextField++;
			nNextPosInField = 0;
		} else {
			// unexpected char; give up
			nNextField = 0;
			nNextPosInField = 0;
		}
	}
	else if (nNextField == 3) {
		// steering direction
		if ((nNextPosInField == 0) && ((cInput == 'L') || (cInput == 'R'))) {
			cSteerDir = cInput;
			nNextPosInField++;
		} else if ((nNextPosInField == 1) && (cInput == ',')) {
			nSteerBearing = 0;
			nNextField++;
			nNextPosInField = 0;
		} else {
			// unexpected char; give up
			nNextField = 0;
			nNextPosInField = 0;
		}
	}
	else if (nNextField == 11) {
		// steering bearing
		if ((cInput >= '0') && (cInput <= '9')) {
			nSteerBearing = (nSteerBearing * 10) + (cInput - '0');
		} else if (cInput == '.') {
			// skip decimal point
		} else if (cInput == ',') {
			nNextField++;
			nNextPosInField = 0;
		} else {
			// unexpected char; give up
			nNextField = 0;
			nNextPosInField = 0;
		}
	}
	else if (nNextField > 11) {
		// time to do something
		//if (nXTError < 10)
		//	cSteerDir = 'N';	// don't steer
		if (nSteerBearing < STEERING_BEARING_MINIMUM)
			cSteerDir = 'N';	// don't steer
		// now start steering
		if (cSteerDir == 'R') {
			// error to right, steer left
			RA3 = 1; // LED5/RELAY1
			// PORTA = 0x0C;		// turn on RA2/RA3 bits
		} else if (cSteerDir == 'L') {
			// error to left, steer right
			RA2 = 1; // LED6/RELAY2
			// RA1 = 1; // LED7/RELAY3
			// RA0 = 1; // LED8/RELAY4
			// PORTA = 0x03;		// turn on RA0/RA1 bits; RELAY4/RELAY3
		} else {
			// don't steer
		}
		if ((cSteerDir == 'L') || (cSteerDir == 'R')) {
			lSteeringCount = STEERING_ON_DURATION;
			lPostSteeringCount = 0;
		}
		// ready to start next sentence
		nNextField = 0;
		nNextPosInField = 0;
	}
	else {
		// process char in field we don't care about
		if (cInput == ',') {
			nNextField++;
			nNextPosInField = 0;
		} else {
			// do nothing; throw char away
		}
	}

	if (OERR) {
		// overrun error
		CREN = 0;
#if SIGNAL_PERMANENT_ERRORS_ON_RELAYS_3_AND_4
		// to signal problem
		PORTA = 0x01;		// turn on RA0; RELAY4
		bPermanentFatalError = 1;
#endif
		lSteeringCount = 0;
		lPostSteeringCount = 0;
		// ignore any partial line recved
		nNextField = 0;
		nNextPosInField = 0;
		CREN = 1;
	}

	RCIF = 0; // clear interrupt flag, ready for next char
}

// unexpected interrupt
else {
	// no way to tell user about problem !!!
	if (!bPermanentFatalError) {
		lSteeringCount = 0;
		lPostSteeringCount = 0;
#if SIGNAL_PERMANENT_ERRORS_ON_RELAYS_3_AND_4
		// to signal problem
		PORTA = 0x02;		// turn on RA1; RELAY3
		bPermanentFatalError = 1;
#endif
	}
}

}

//--------------------------------------------------------------------------