break;

			/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
		/* Reading the RSSI from the SPI									 */
		case ECHO_READ_RSSI_1:
			ECHO_SPIxDR = 0;
			echoDriverNextState = ECHO_READ_RSSI_2;
			break;

		/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
		/* Reading the RSSI from the SPI									 */
		case ECHO_READ_RSSI_2:
			echoEmptyPtr[0] &= 0xC0;			/* Clear the RSSI bits		 */
			echoEmptyPtr[0] |= (temp & 0x0F);	/* Copy in bottom four bits	 */
			echoEmptyPtr[0] += ((temp & 0xF0) >> 4);	/* Add top four bits */
														/* for RSSI		 	 */
			echoEmptyPtr[0] |= ECHO_RSSI_BIT;	/* Indicate RSSI measured	 */

			echoEmptyPtr[1] |= ECHO_BUFFER_FULL;	/* Signal buffer full	 */

			echoEmptyPtr += ECHO_MAX_DATA_SIZE+2;
			if (echoEmptyPtr >= (echoRxBuffer+sizeof(echoRxBuffer))) {
				echoEmptyPtr = echoRxBuffer;
			}

			Echo_ExitConfig();
			ECHO_SEB = 0;

			status.Bits.Busy = 0;
			status.Bits.Rx = 0;

			echoDriverNextState = ECHO_READY;
			break;


		/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
		/* Oh dear something went wrong!									 */
		default:
			status.Bits.Error = 1;
			break;
	}
}

#pragma CODE_SEG DEFAULT

/******************************************************************************
* Return the status of the driver. Updates echoNextMessage pointer if another
* message is ready and the current message buffer has been released
* (by clearing the buffer full bit)
******************************************************************************/
tECHO_STATUS Echo_DriverStatus(void) {
	unsigned char *tempPtr;
	tECHO_STATUS toReturn = status;
	
	/* echoFullPtr is either full (so it will be returned next) or empty.	 */
	/* If it is empty, the last message returned has been released, so check */
	/* if there is another waiting in the next buffer.						 */
	if ((echoFullPtr[1] & ECHO_BUFFER_FULL) != 0) {
		echoNextMessage = echoFullPtr;
		toReturn.Bits.MsgReady = 1;

		if ((echoNextMessage[0] & ECHO_CHECKSUM_ERROR) != 0) {
			toReturn.Bits.Checksum = 1;
		}
	}
	else {
		tempPtr = echoFullPtr + ECHO_MAX_DATA_SIZE+2;
		if (tempPtr >= (echoRxBuffer+sizeof(echoRxBuffer))) {
			tempPtr = echoRxBuffer;
		}

		if ((tempPtr[1] & ECHO_BUFFER_FULL) != 0) {
			echoFullPtr = tempPtr;
			echoNextMessage = tempPtr;

			toReturn.Bits.MsgReady = 1;

			if ((echoNextMessage[0] & ECHO_CHECKSUM_ERROR) != 0) {
				toReturn.Bits.Checksum = 1;
			}
		}
	}

	#ifdef ECHO_LVD
		toReturn.Bits.LVD = ECHO_LVD;
	#endif

	return toReturn;
}

/******************************************************************************
* Clear the error and timeout flags
******************************************************************************/
void Echo_ClearError(void) {
	status.Bits.Error = 0;
	status.Bits.Timeout = 0;
}

/******************************************************************************
* Take the STROBE line high (if it is under driver control).
* When STROBE is high, Echo will always be on in Rx mode.
******************************************************************************/
void Echo_StrobeHigh(void) {
	#ifdef ECHO_STROBE
		ECHO_STROBE = 1;
		ECHO_STROBE_DDR = 1;
	#endif
}

/******************************************************************************
* Take the STROBE line low (if it is under driver control).
* When STROBE is low, Echo will stay in Standby once entered.
******************************************************************************/
void Echo_StrobeLow(void) {
	#ifdef ECHO_STROBE
		ECHO_STROBE = 0;
		ECHO_STROBE_DDR = 1;
	#endif
}

/******************************************************************************
* Tristate the STROBE line low (if it is under driver control). When STROBE is
* tristated, Echo's internal strobe oscillator is used (if SOE bit is 1) to
* control on/off time.
******************************************************************************/
void Echo_StrobeTriState(void) {
	#ifdef ECHO_STROBE
		ECHO_STROBE_DDR = 0;
	#endif
}

/******************************************************************************
* Setup and start off a delayed configuration. Schedules a 1.2ms wait before
* sending 'echoCommand' and 'echoRegCounter' number of registers to/from
* 'echoRegPtr'.
******************************************************************************/
void Echo_StartDelayedConfig(void) {
	/* Echo will be reset back to Rx mode: make flags consistent			 */
	status.Word &= 0x4154;				/* Clear all but Timeout, Error,	 */
										/* Overrun, Enabled & RSSI_Enabled	 */
	status.Bits.Busy = 1;

	ECHO_TIE &= ~ECHO_TIMER_INT;			/* In case we're transmitting	 */
	Echo_EnterConfig();

	bitCounter = ECHO_1200uS_DELAY;
	echoDriverNextState = ECHO_CONFIG_DELAY;

	Echo_KickOffTimer();
}

/******************************************************************************
* Frequency control functions - one version for OOK and one for FSK.		 
******************************************************************************/
#if ECHO_MODE_VALUE == ECHO_OOK

/******************************************************************************
* Set frequency using the user friendly mode - specify the carrier used for
* OOK. Carrier is a 12 bit value which can be derived from the datasheet.
******************************************************************************/
	void Echo_SetFreq(unsigned int carrier) {
		echoRegisters[ECHO_CONFIG2_REG] &= ~ECHO_BIT_FRM;
		echoRegisters[ECHO_F1_REG] = ((carrier & 0x0F00)>>8);
		echoRegisters[ECHO_F0_REG] =  (carrier & 0x00FF);

		echoCommand		= BUILDCMD(CMD_EIGHT, ECHO_CONFIG2_REG, 1);
		echoRegPtr		= &echoRegisters[ECHO_CONFIG2_REG];
		echoRegCounter	= 8;

		Echo_StartDelayedConfig();
	}

/******************************************************************************
* Set frequency using the direct mode - specify the carrier and local
* oscillator frequencies used for OOK. localOscillator and carrier0 are 12 bit
* values that may be derived from datasheet.
******************************************************************************/
	void Echo_SetFreqNoFRM(unsigned int localOscillator,\
						   unsigned int carrier0) {
		echoRegisters[ECHO_CONFIG2_REG] |= ECHO_BIT_FRM;

		echoRegisters[ECHO_F1_REG] = ((localOscillator & 0x0F00)>>8);
		echoRegisters[ECHO_F0_REG] =  (localOscillator & 0x00FF);
		
		echoRegisters[ECHO_FT2_REG] = ((carrier0 & 0x0FF0) >> 4);
		echoRegisters[ECHO_FT1_REG] = ((carrier0 & 0x000F) << 4);
		
		echoCommand		= BUILDCMD(CMD_EIGHT, ECHO_CONFIG2_REG, 1);
		echoRegPtr		= &echoRegisters[ECHO_CONFIG2_REG];
		echoRegCounter	= 8;

		Echo_StartDelayedConfig();
	}

#else

/******************************************************************************
* Set frequency using the user friendly mode - specify the carrier frequency
* and delta used to calculate the actual carriers for a 0 and 1 used for FSK.
* The carrier is 12 bit, deltaF is four bits and can be derived using 
* formulae in the datasheet.
******************************************************************************/
	void Echo_SetFreq(unsigned int carrier, unsigned char deltaF) {
		echoRegisters[ECHO_CONFIG2_REG] &= ~ECHO_BIT_FRM;
		echoRegisters[ECHO_F1_REG] = ((deltaF & 0x0F)<<4) | \
									 ((carrier & 0x0F00)>>8);
		echoRegisters[ECHO_F0_REG] =  (carrier & 0x00FF);

		echoCommand		= BUILDCMD(CMD_EIGHT, ECHO_CONFIG2_REG, 1);
		echoRegPtr		= &echoRegisters[ECHO_CONFIG2_REG];
		echoRegCounter	= 8;

		Echo_StartDelayedConfig();
	}

/******************************************************************************
* Set frequency using the direct mode - specify the carriers for transmitting
* a 0 and 1 explicitly and the local oscillator frequency used for FSK.
* The values are 12 bit and can be derived using formulae in the datasheet.
******************************************************************************/
	void Echo_SetFreqNoFRM(unsigned int localOscillator,
						   unsigned int carrier0,
						   unsigned int carrier1) {

		echoRegisters[ECHO_CONFIG2_REG] |= ECHO_BIT_FRM;

		echoRegisters[ECHO_F1_REG] = ((localOscillator & 0x0F00)>>8);
		echoRegisters[ECHO_F0_REG] = (localOscillator & 0x00FF);

		echoRegisters[ECHO_FT2_REG] = ((carrier0 & 0x0FF0) >> 4);
		echoRegisters[ECHO_FT1_REG] = ((carrier0 & 0x000F) << 4) | \
									  ((carrier1 & 0x0F00)>>8);
		echoRegisters[ECHO_FT0_REG] = (carrier1 & 0x00FF);

		echoCommand		= BUILDCMD(CMD_EIGHT, ECHO_CONFIG2_REG, 1);
		echoRegPtr		= &echoRegisters[ECHO_CONFIG2_REG];
		echoRegCounter	= 8;

		Echo_StartDelayedConfig();
	}

#endif
/*****************************************************************************/

/******************************************************************************
* Set the input sensitivity on Echo to level. Level must be in the range 0-3.
* Sets the ILA bits in Echo (see datasheet for more info.)
******************************************************************************/
void Echo_SetRxSensitivity(unsigned char level) {
	echoRegisters[ECHO_CONFIG3_REG] &= 0xF3;		/* Clear the ILA bits	 */
	echoRegisters[ECHO_CONFIG3_REG] |= ((level&0x03)<<2);  /* Copy in 2 bits */
														   /* of level 	 	 */

	echoCommand		= BUILDCMD(CMD_ONE, ECHO_CONFIG3_REG, 1);
	echoRegPtr		= &echoRegisters[ECHO_CONFIG3_REG];
	echoRegCounter	= 1;

	Echo_StartDelayedConfig();
}

/******************************************************************************
* Set the output power on Echo to level. Level must be in the range 0-3.
* Sets the OLA bits in Echo (see datasheet for more info.)
******************************************************************************/
void Echo_SetTxPower(unsigned char level) {
	echoRegisters[ECHO_CONFIG3_REG] &= 0xFC;		/* Clear the OLA bits	 */
	echoRegisters[ECHO_CONFIG3_REG] |= (level&0x03);	   /* Copy in 2 bits */
														   /* of level 	  	 */
	echoCommand		= BUILDCMD(CMD_ONE, ECHO_CONFIG3_REG, 1);
	echoRegPtr		= &echoRegisters[ECHO_CONFIG3_REG];
	echoRegCounter	= 1;

	Echo_StartDelayedConfig();
}


/******************************************************************************
* Reset the Automatic Gain Control to maximum.
* Stays at maximum as long as RAGC=1.
******************************************************************************/
void Echo_RagcHigh() {
	echoRegisters[ECHO_COMMAND_REG] |= ECHO_BIT_RAGC;

	echoCommand		= BUILDCMD(CMD_ONE, ECHO_COMMAND_REG, 1);
	echoRegPtr		= &echoRegisters[ECHO_COMMAND_REG];
	echoRegCounter	= 1;

	Echo_StartDelayedConfig();
}

/******************************************************************************
* Allow Automatic Gain Control to take effect again.
******************************************************************************/
void Echo_RagcLow() {
	echoRegisters[ECHO_COMMAND_REG] &= ~ECHO_BIT_RAGC;

	echoCommand		= BUILDCMD(CMD_ONE, ECHO_COMMAND_REG, 1);
	echoRegPtr		= &echoRegisters[ECHO_COMMAND_REG];
	echoRegCounter	= 1;

	Echo_StartDelayedConfig();
}

/******************************************************************************
* Freeze the Automatic Gain Control to its current value.
******************************************************************************/
void Echo_FagcHigh() {
	echoRegisters[ECHO_COMMAND_REG] |= ECHO_BIT_FAGC;

	echoCommand		= BUILDCMD(CMD_ONE, ECHO_COMMAND_REG, 1);
	echoRegPtr		= &echoRegisters[ECHO_COMMAND_REG];
	echoRegCounter	= 1;

	Echo_StartDelayedConfig();
}

/******************************************************************************
* Allow Automatic Gain Control to unfreeze again.
******************************************************************************/
void Echo_FagcLow() {
	echoRegisters[ECHO_COMMAND_REG] &= ~ECHO_BIT_FAGC;

	echoCommand		= BUILDCMD(CMD_ONE, ECHO_COMMAND_REG, 1);
	echoRegPtr		= &echoRegisters[ECHO_COMMAND_REG];
	echoRegCounter	= 1;

	Echo_StartDelayedConfig();
}

/******************************************************************************
* Enable the RSSI module and automatically read RSSI during reception of
* messages. The received RSSI reading will be stored in the buffer along 
* with the message.
******************************************************************************/
#ifdef ECHO_RSSIC	
	void Echo_EnableRSSI(void) {
		status.Bits.RSSI_Enabled = 1;

		echoRegisters[ECHO_COMMAND_REG] |= ECHO_BIT_RSSIE;

		echoCommand		= BUILDCMD(CMD_ONE, ECHO_COMMAND_REG, 1);
		echoRegPtr		= &echoRegisters[ECHO_COMMAND_REG];
		echoRegCounter	= 1;

		Echo_StartDelayedConfig();
	}
#endif

/******************************************************************************
* Disable the RSSI module and stop automatically reading the RSSI during
* reception.
******************************************************************************/
#ifdef ECHO_RSSIC
	void Echo_DisableRSSI(void) {
		status.Bits.RSSI_Enabled = 0;

		echoRegisters[ECHO_COMMAND_REG] &= ~ECHO_BIT_RSSIE;
  	
		echoCommand		= BUILDCMD(CMD_ONE, ECHO_COMMAND_REG, 1);
		echoRegPtr		= &echoRegisters[ECHO_COMMAND_REG];
		echoRegCounter	= 1;

		Echo_StartDelayedConfig();
	}
#endif

/******************************************************************************
* Read the RSSI from Echo's registers. Starts a conversion (which lasts _at 
* least_ 32*Tdigclk (around 53usec)), then reads the RSSI value and stores it
* in echoRSSIResult. Requires the RSSI module to be enabled - call 
* Echo_EnableRSSI. Also, if Echo is in transmit mode, the RSSI cannot be read -
* status bit Error is set.
******************************************************************************/
#ifdef ECHO_RSSIC
	void Echo_ReadDigitalRSSI(void) {
		/* Can't read RSSI while transmitting - in any case, toggling CONFB  */
		/* to read the RSSI would reset Echo and abort transmission, so just */
		/* don't do it. Also, we require the RSSI module to be enabled 		 */
		/* before reading the RSSI.											 */
		if (status.Bits.Mode == 1 || status.Bits.RSSI_Enabled == 0) {
			status.Bits.Error = 1;
			return;
		}