The Falcom FSA03 is an inexpensive Ublox 5 (UBX-G5010) GPS module with a small footprint which featuring the Sarantel quadrifilar helix antenna.

Ublox modules are capable of operating above 60,000 feet, provided they are configured and placed in airborne mode. The FSA03 does not include any EEPROM or Flash memory, and as such is unable to retain settings unless its RAM is buffered by backup battery. The module should be programmed with UBX whenever power has been lost to place it in airborne mode.

Some FSA03 modules have been found to have a default baud rate of 9600, whilst others have a default baud rate of 38400, which may be difficult to parse if not using a UART (ie software serial).

Given its unshielded board, the FSA03 is likely to be quite sensitive to ESD - the datasheet suggests it be treated as 'extremely sensitive to ESD'. It's probably a good idea to solder the module last, and avoid touching the exposed board where possible.

The datasheet is somewhat ambiguous regarding signals/tracks on the host board underneath the FSA03, mentioning 'Note: no ground under the component' - it's not clear (to me at least) whether this refers to the fact that the underside of the module isn't grounded, or is a warning not to place any ground planes or tracks below the module (on the host board).

The FSA03 provides a 1 Pulse-Per-Second output synchronised to UTC on its TM pin - this is often used as an indicator light for the module obtaining lock, but it's not entirely accurate - the 1PPS output will continue for some time even if the module loses lock, so long as it thinks its internal RTC is accurate.

The module draws around 40mA typically, though upto 100mA when acquiring lock.

The antenna on this module appears to be slightly wobbly and this may be one of the causes of the module not getting a lock for long periods of time. Its recommended that you secure it (perhaps with glue) in a position that works.

The FSA03 is primarily configured through Ublox's binary protocol (UBX), though some parameters can be altered using NMEA sentences. The UBX protocol specification covers configuring the module.

// This code gives an example of configuring an FSA03 connected to a software serial port on an Arduino
 
#include <NewSoftSerial.h>
 
NewSoftSerial nss(3, 2); 
 
void setup() {
 
	// Start up serial ports
	nss.begin(38400);
	Serial.begin(115200); // used for debug ouput
 
	delay(2000); // Give the GPS time to come boot
 
	// Lower the baud rate to 9600 from 38.4k
	Serial.print("Setting uBlox port mode: ");
	uint8_t setPort[] = {0xB5, 0x62, 0x06, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0xD0, 0x08, 0x00, 0x00, 0x80, 0x25, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9E, 0x95};
	sendUBX(setPort, sizeof(setPort)/sizeof(uint8_t));
 
	// Switch baud rates on the software serial
	Serial.println("Switching to 9600b GPS serial");
	nss.begin(9600);
	delay(1000);
 
	// Set the navigation mode (Airborne, 1G)
	Serial.print("Setting uBlox nav mode: ");
	uint8_t setNav[] = {0xB5, 0x62, 0x06, 0x24, 0x24, 0x00, 0xFF, 0xFF, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10, 0x27, 0x00, 0x00, 0x05, 0x00, 0xFA, 0x00, 0xFA, 0x00, 0x64, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xDC};
	sendUBX(setNav, sizeof(setNav)/sizeof(uint8_t));
	getUBX_ACK(setNav);
 
 
	// Switch off GLL
	Serial.print("Switching off NMEA GLL: ");
	uint8_t setGLL[] = { 0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x2B };
	sendUBX(setGLL, sizeof(setGLL)/sizeof(uint8_t));
	getUBX_ACK(setGLL);
 
	// Switch off GSA
	Serial.print("Switching off NMEA GSA: ");
	uint8_t setGSA[] = { 0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x32 };
	sendUBX(setGSA, sizeof(setGSA)/sizeof(uint8_t));
	getUBX_ACK(setGSA);
 
	// Switch off GSV
	Serial.print("Switching off NMEA GSV: ");
	uint8_t setGSV[] = { 0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x39 };
	sendUBX(setGSV, sizeof(setGSV)/sizeof(uint8_t));
	getUBX_ACK(setGSV);
 
	// Switch off RMC
	Serial.print("Switching off NMEA RMC: ");
	uint8_t setRMC[] = { 0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x40 };
	sendUBX(setRMC, sizeof(setRMC)/sizeof(uint8_t));
	getUBX_ACK(setRMC);
 
}
 
// Dump bytes to debug as they appear
void loop() {
	if (nss.available()) {
		Serial.print(nss.read(), BYTE);
	}
}
 
// Send a byte array of UBX protocol to the GPS
void sendUBX(uint8_t *MSG, uint8_t len) {
	for(int i=0; i<len; i++) {
		nss.print(MSG[i], BYTE);
		Serial.print(MSG[i], HEX);
	}
	Serial.println();
}
 
 
// Calculate expected UBX ACK packet and parse UBX response from GPS
boolean getUBX_ACK(uint8_t *MSG) {
	uint8_t b;
	uint8_t ackByteID = 0;
	uint8_t ackPacket[10];
	int startTime = millis();
	Serial.print(" * Reading ACK response: ");
 
	// Construct the expected ACK packet    
	ackPacket[0] = 0xB5;	// header
	ackPacket[1] = 0x62;	// header
	ackPacket[2] = 0x05;	// class
	ackPacket[3] = 0x01;	// id
	ackPacket[4] = 0x02;	// length
	ackPacket[5] = 0x00;
	ackPacket[6] = MSG[2];	// ACK class
	ackPacket[7] = MSG[3];	// ACK id
	ackPacket[8] = 0;		// CK_A
	ackPacket[9] = 0;		// CK_B
 
	// Calculate the checksums
	for (uint8_t i=2; i<8; i++) {
		ackPacket[8] = ackPacket[8] + ackPacket[i];
		ackPacket[9] = ackPacket[9] + ackPacket[8];
	}
 
	while (1) {
 
		// Test for success
		if (ackByteID > 9) {
				// All packets in order!
				Serial.println(" (SUCCESS!)");
				return true;
		}
 
		// Timeout if no valid response in 3 seconds
		if (millis() - startTime > 3000) { 
			Serial.println(" (FAILED!)");
			return false;
		}
 
		// Make sure data is available to read
		if (nss.available()) {
			b = nss.read();
 
			// Check that bytes arrive in sequence as per expected ACK packet
			if (b == ackPacket[ackByteID]) { 
				ackByteID++;
				Serial.print(b, HEX);
			} else {
				ackByteID = 0;	// Reset and look again, invalid order
			}
 
		}
	}
}
 

If you only need to turn of the sentances then you can just use NMEA commands:

// Turning off all GPS NMEA strings apart from GPGGA on the uBlox modules
Serial.print("$PUBX,40,GLL,0,0,0,0*5C\r\n");
Serial.print("$PUBX,40,ZDA,0,0,0,0*44\r\n");
Serial.print("$PUBX,40,VTG,0,0,0,0*5E\r\n");
Serial.print("$PUBX,40,GSV,0,0,0,0*59\r\n");
Serial.print("$PUBX,40,GSA,0,0,0,0*4E\r\n");
Serial.print("$PUBX,40,RMC,0,0,0,0*47\r\n");

As the FSA03 doesn't have any RAM or flash memory, its RAM must be buffered by a backup battery to retain settings. So long as the backup battery remains in place, you can can save your settings as per page 99 of the UBX protocol specification “Clear, Save and Load configurations”.

By default, FSA03 modules are configured to output several NMEA sentences including GPRMC, GPGGA & GPVTG. Of these, GPGGA is the most useful for high altitute balloon applications as it contains altitude data. Un-necessary sentences can be disabled, see the configuration section for more information.

Ublox 5 based GPS modules implement a proprietary NMEA extension in the form of a polled sentence which reports all navigation parameters of intrest (to us at least) in a single sentence when requested. Using this provides advantages in that you can request an update exactly when you need it, and you only need to parse one specific sentence to capture latitude, longitude, altitude, speed, course, etc. If you're using a software serial port to your GPS module, this is likely to be very useful.

To use the sentence firstly disable any GPS sentences which are currently switched on:

Serial.println("$PUBX,40,GGA,0,0,0,0*5A");
Serial.println("$PUBX,40,GSA,0,0,0,0*4E");
Serial.println("$PUBX,40,RMC,0,0,0,0*47");
Serial.println("$PUBX,40,GSV,0,0,0,0*59");
Serial.println("$PUBX,40,VTG,0,0,0,0*5E");

The sentence can be requested by sending the string “$PUBX,00*33”:

Serial.println("$PUBX,00*33");

The module responds (within 1 second) with the current navigation data in the following format:

$PUBX,00,hhmmss.ss,Latitude,N,Longitude,E,AltRef,NavStat,Hacc,Vacc,SOG,COG,Vvel,ageC,HDOP,VDOP,TDOP,GU,RU,DR,*cs<CR><LF>

For details see page 52 of the UBX protocol specification “Proprietary Messages, UBX00”.

Here's a copy of the http://arduiniana.org/libraries/tinygps/ library by Mikal Hart modified to decode the polled Ublox sentence containing everything likely to be needed for high altitude ballooning. A new method sats() has been added, which will return the number of GPS satellites currently being tracked by the module.