/******************************************************************************
MODE:		AML--#GPS+accelerator+compass
MCU:		Cyan eCOG1k
COMPILER:	CyanIDE v1.41
FILE NAME:	GPS C source code files
******************************************************************************/

#define gps_code

/******************************************************************************
Project level include files.
******************************************************************************/

#include "gps.h"

/******************************************************************************
Declaration of static functions.
******************************************************************************/
int __irq_code _str_cmp(char *str1,char *str2);
void gps_initialization(void);
void __irq_code RMC_receive(void);
void __irq_code GGA_receive(void);
void __irq_code GSA_receive(void);
void __irq_code GSV_receive(void);
void __irq_code GPS_one_group_receive(void);
void __irq_code GPS_STR_head_receive(void);

void __irq_code GPS_data_transmit(void);
void __irq_code GPS_transmit_one_byte(char *transmit_P);

/******************************************************************************
NAME
    _str_cmp

SYNOPSIS
    int __irq_code _str_cmp(char *str1,char *str2)

FUNCTION
    Be invoked for interrupt function.
    Compares the string pointed to by str1 to the string pointed to by str2.
	Returns an integer 0(equal) or 1(not equal).

RETURNS
    0 or 1.
******************************************************************************/
int __irq_code _str_cmp(char *str1,char *str2)
{
	int cmp_value = 0;
	while((*str1 != '\0') || (*str2 != '\0'))
	{
		if(*str1 != *str2) break;
		else
		{		
			str1++;
			str2++;
		}
	}
	if((*str1 == '\0') && (*str2 == '\0')) cmp_value = 0;
	else cmp_value = 1;
	return(cmp_value);
}



/******************************************************************************
NAME
    usr_rx_handler

SYNOPSIS
    void __irq_entry usr_rx_handler(void)

FUNCTION
    Interrupt handler for usr receive ready
    Receive one byte data from GPS mode.

RETURNS
    Nothing.
******************************************************************************/

void __irq_entry usr_rx_handler(void)
{
	
	int test = fd.duart.a_sts.rx_1b_rdy;		// Read rx interrupt status register
	
	test += fd.duart.a_sts.rx_act;				// Ensure that the receiver is currently inactive.
	if (1 == test)								// Received character ready?
	{
		c = rg.duart.a_rx;					// Yes, read receive register
		if(c >= '\x80') goto usr_rx_handler_end;// If Receive value isn't ASCII,abandon current value.
		
		switch(c)								// Judge receive value.
		{
			case '$' :							// Receive value equ $?
				checksum = 0;					// Start count checksum;
				receive_buffer_count = 0;		// CLR receive character counter.
				str_head_flag = _GPHAD_;
				break;
			
			case CR:												// Receive value equ ENTER?
				
			case LF:												// Receive value equ line advance?
				
				break;
				
			default:												// Other value 
				checksum ^= c;										// Count checksum.
				
				switch(str_head_flag)
				{
					case _GPHAD_:
						GPS_STR_head_receive();
						break;
					
					case _GPGGA_:
						GGA_receive();
						break;
						
					case _GPGSA_:
						GSA_receive();
						break;
						
					case _GPGSV_:
						GSV_receive();
						break;
						
					case _GPRMC_:
						RMC_receive();
						break;
						
					
					default:
						break;
				}
				break;	
		}
	}
usr_rx_handler_end:
	nop();
}

/******************************************************************************
NAME
    usr_ex_handler

SYNOPSIS
    void __irq_entry usr_ex_handler(void)

FUNCTION
    Interrupt handler for usr exceptions

RETURNS
    Nothing.
******************************************************************************/

void __irq_entry usr_ex_handler(void)
{
	// Clear any exceptions
    rg.duart.a_int_clr = 0xfff2;
	// Disable any exceptions
    rg.duart.a_int_dis = 0xfff2;
}


/******************************************************************************
NAME
    gps_initialization

SYNOPSIS
    void gps_initialization(void)

FUNCTION
    Display gps fix character.

RETURNS
    Nothing.
******************************************************************************/
void gps_initialization(void)
{
	char *P;
	int i;
	P = "$GPGSA,";
	for(i = 0;i < 7;i++)
	{
		GPGSA.head[i] = *P;
		P++;
	}
	
	P = "$GPGGA,";
	for(i = 0;i < 7;i++)
	{
		GPGGA.head[i] = *P;
		P++;
	}
	
	P = "$GPRMC,";
	for(i = 0;i < 7;i++)
	{
		GPRMC.head[i] = *P;
		P++;
	}
	
	P = "$GPGSV,";
	for(i = 0;i < 7;i++)
	{
		GPGSV1.head[i] = *P;
		P++;
	}
	
	P = "$GPGSV,";
	for(i = 0;i < 7;i++)
	{
		GPGSV2.head[i] = *P;
		P++;
	}
	
	P = "$GPGSV,";
	for(i = 0;i < 7;i++)
	{
		GPGSV3.head[i] = *P;
		P++;
	}
	
	P = "$GPGSV,";
	for(i = 0;i < 7;i++)
	{
		GPGSV4.head[i] = *P;
		P++;
	}
	GPGSA.CR_LF[0] = CR;
	GPGSA.CR_LF[1] = LF;
	
	GPGGA.CR_LF[0] = CR;
	GPGGA.CR_LF[1] = LF;
	
	GPRMC.CR_LF[0] = CR;
	GPRMC.CR_LF[1] = LF;
	
	GPGSV1.CR_LF[0] = CR;
	GPGSV1.CR_LF[1] = LF;
	
	GPGSV2.CR_LF[0] = CR;
	GPGSV2.CR_LF[1] = LF;
	
	GPGSV3.CR_LF[0] = CR;
	GPGSV3.CR_LF[1] = LF;
	
	GPGSV4.CR_LF[0] = CR;
	GPGSV4.CR_LF[1] = LF;
	
	GPS_TX_ready_flag = 0;
	receive_buffer_count = 0;
	receive_flag = 0;
	temp_count = 0;
	gps_state = '0';
	GPS_TX_gradation_flag = 0;
	GPS_TX_count = 0;
	_GSV_TX_sum_ = 0;
	
	GPGGA_TX_pointer = (char *)(&GPGGA);
	GPGSA_TX_pointer = (char *)(&GPGSA);
	GPGSV1_TX_pointer = (char *)(&GPGSV1);
	GPGSV2_TX_pointer = (char *)(&GPGSV2);
	GPGSV3_TX_pointer = (char *)(&GPGSV3);
	GPGSV4_TX_pointer = (char *)(&GPGSV4);
	GPRMC_TX_pointer = (char *)(&GPRMC);
	    
}   
    
/******************************************************************************
NAME
    display_gps_data

SYNOPSIS
    void display_gps_data(void)

FUNCTION
    Display gps data.

RETURNS
    Nothing.
******************************************************************************/

/******************************************************************************
end
******************************************************************************/

void __irq_code RMC_receive(void)
{
	switch(receive_flag)
	{
		case RMC_TIME:									// Receive UTC time character.
			if(c != ',')
			{
				GPRMC.UTC_timer[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 10)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.UTC_timer[receive_buffer_count] = ',';
				while(receive_buffer_count < (10 - 1))
				{
					receive_buffer_count ++;
					GPRMC.UTC_timer[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_WORK_STATE;
			}
			break;
			
			
		case RMC_WORK_STATE:									// Receive UTC time character.
			if(c != ',')
			{
				GPRMC.work_state[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 2)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.work_state[receive_buffer_count] = ',';
				while(receive_buffer_count < (2 - 1))
				{
					receive_buffer_count ++;
					GPRMC.work_state[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_LATITUDE;
			}
			break;
		
		case RMC_LATITUDE :								// Receive latitude character.
			if(c != ',')
			{
				GPRMC.latitude[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 10)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.latitude[receive_buffer_count] = ',';
				while(receive_buffer_count < (10 - 1))
				{
					receive_buffer_count ++;
					GPRMC.latitude[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_LATITUDE_ASPECT;
			}
			break;
			
		
		case RMC_LATITUDE_ASPECT:						// Receive latitude aspect character.
			if(c != ',')
			{
				GPRMC.latitude_aspect[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 2)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.latitude_aspect[receive_buffer_count] = ',';
				while(receive_buffer_count < (2 - 1))
				{
					receive_buffer_count ++;
					GPRMC.latitude_aspect[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_LONGITUDE;
			}
			break;
		
		
		case RMC_LONGITUDE:								// Receive longitude character.
			if(c != ',')
			{
				GPRMC.longitude[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 11)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.longitude[receive_buffer_count] = ',';
				while(receive_buffer_count < (11 - 1))
				{
					receive_buffer_count ++;
					GPRMC.longitude[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_LONGITUDE_ASPECT;
			}
			break;
		
		
		case RMC_LONGITUDE_ASPECT:						// Receive longitude aspect character.
			if(c != ',')
			{
				GPRMC.longitude_aspect[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 2)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.longitude_aspect[receive_buffer_count] = ',';
				while(receive_buffer_count < (2 - 1))
				{
					receive_buffer_count ++;
					GPRMC.longitude_aspect[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_SPEED;
			}
			break;
			
		
		
		case RMC_SPEED:									// Receive speed character.
			if(c != ',')
			{
				GPRMC.speed[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 6)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.speed[receive_buffer_count] = ',';
				while(receive_buffer_count < (6 - 1))
				{
					receive_buffer_count ++;
					GPRMC.speed[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_ASPECT;
			}
			break;
		
		case RMC_ASPECT:									//Not receive aspect character.
			if(c != ',')
			{
				GPRMC.bearing_pointer[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 6)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.bearing_pointer[receive_buffer_count] = ',';
				while(receive_buffer_count < (6 - 1))
				{
					receive_buffer_count ++;
					GPRMC.bearing_pointer[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_DATE;
			}
			break;	
			
			
		case RMC_DATE:									// Receive UTC date character.
			if(c != ',')
			{
				GPRMC.UTC_date[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 7)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.UTC_date[receive_buffer_count] = ',';
				while(receive_buffer_count < (7 - 1))
				{
					receive_buffer_count ++;
					GPRMC.UTC_date[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_SUN_DATA1;
			}
			break;
			
			
		case RMC_SUN_DATA1:									// Receive UTC date character.
			if(c != ',')
			{
				GPRMC.sun_data1[receive_buffer_count] = c;
				receive_buffer_count++;
				if(receive_buffer_count == 6)
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.sun_data1[receive_buffer_count] = ',';
				while(receive_buffer_count < (6 - 1))
				{
					receive_buffer_count ++;
					GPRMC.sun_data1[receive_buffer_count] = ' ';
					
				}
				
				receive_buffer_count = 0;
				receive_flag = RMC_SUN_DATA2;
			}
			break;
			
		case RMC_SUN_DATA2:									// Receive UTC date character.
		
			if(c != '*')
			{
				GPRMC.sun_data2[receive_buffer_count] = c;
				if((++receive_buffer_count) > (4 - 1))
				{
					receive_buffer_count--;
				}
			}
			else
			{
				GPRMC.end_flag = '*';
				
				c2 = checksum & 0x0f; c1 = ((checksum >> 4) & 0x0f);	// Change checksum to ASCII.
				if (c1 < 10) c1+= '0'; else c1 += 'A' - 10;
				if (c2 < 10) c2+= '0'; else c2 += 'A' - 10;
				
				while(receive_buffer_count < (4 - 1))
				{
					receive_buffer_count ++;
					GPRMC.sun_data2[receive_buffer_count] = ' ';
				}
				
				receive_flag = RMC_CHECKSUM;
				receive_buffer_count = 0;
			}
			break;
			
		case RMC_CHECKSUM:									// Receive UTC date character.
			
				GPRMC.checksum[receive_buffer_count] = c;
				if(receive_buffer_count++ >= 1)
				{
					if((c1 == GPRMC.checksum[0]) && (c2 == GPRMC.checksum[1]))
					{
						
					}