GPS

#include <msp430.h>''
#include "Config.h"
#include "Paper_Display.h"
typedef struct SaveData
{
    char GPS_Buffer[GPS_Buffer_Length];
    char isGetData;     //是否获取到GPS数据
    char isParseData;   //是否解析完成
    char UTCTime[UTCTime_Length];       //UTC时间
    char latitude[latitude_Length];     //纬度
    char N_S[N_S_Length];       //N/S
    char longitude[longitude_Length];       //经度
    char E_W[E_W_Length];       //E/W
    char isUsefull;     //定位信息是否有效
} _SaveData;
_SaveData Save_Data;
char USART_RX_BUF[USART_REC_LEN];
char USART_TX_BUF[USART_REC_LEN];
int point1=0;
void error()
{

    while (1)
    {
        Print_Str("ERROR!");
    }
}

void clrStruct()
{
    Save_Data.isGetData = false;
    Save_Data.isParseData = false;
    Save_Data.isUsefull = false;
    memset(Save_Data.GPS_Buffer, 0, GPS_Buffer_Length);      //清空
    memset(Save_Data.UTCTime, 0, UTCTime_Length);
    memset(Save_Data.latitude, 0, latitude_Length);
    memset(Save_Data.N_S, 0, N_S_Length);
    memset(Save_Data.longitude, 0, longitude_Length);
    memset(Save_Data.E_W, 0, E_W_Length);

}

void displayGpsBuffer()
{

    if (Save_Data.isParseData)
        {
            Save_Data.isParseData = false;

//            Print_Str("Save_Data.UTCTime = ");
//            Print_Str(Save_Data.UTCTime);
//            Print_Str("\r\n");

            if(Save_Data.isUsefull)
            {
                Save_Data.isUsefull = false;

                Init_buff();       //清空缓存
 //               display("XMU GPS ", 10, 10,TimesNewRoman,1,0,0);
 //               display("Longitude=", 10, 40,TimesNewRoman,1,0,0);
                display(Save_Data.longitude, 10, 10,TimesNewRoman,1,0,0);
                display(Save_Data.E_W, 200, 10,TimesNewRoman,1,0,0);
 //               display("Latitude=", 10, 70,TimesNewRoman,1,0,0);
                display(Save_Data.latitude, 10, 70,TimesNewRoman,1,0,0);
                display(Save_Data.N_S, 200, 70,TimesNewRoman,1,0,0);
                DIS_IMG(5);
                Save_Data.isUsefull = false;
            }

            else
            {

                Init_buff();       //清空缓存

                display("WAIT...", 10, 10,TimesNewRoman,1,0,0);
                DIS_IMG(5);
            }
        }
}




const char* strstr(const char* src, const char* sub)
{
    const char *bp;
    const char *sp;
    if(!src || !sub)
    {
        return src;
    }
    /* 遍历src字符串  */
    while(*src)
    {
        /* 用来遍历子串 */
        bp = src;
        sp = sub;
        do
        {
            if(!*sp)  /*到了sub的结束位置，返回src位置   */
                return src;
        }while(*bp++ == *sp ++);
        src ++;
    }
    return NULL;
}
void *memset(void *dest, char *src, int count)
{
    void *ptr = dest;
    if (NULL == dest || NULL == src || count <= 0)
    return NULL;

    while (count--)
    *(char *)dest++ = *(char *)src;

    return ptr;
}
void *memcpy(void *dest, const void *src, int count)
{
    void *ptr = dest;
    if (NULL == dest || NULL == src || count <= 0)
    return NULL;

    while (count--)
    *(char *)dest++ = *(char *)src++;

    return ptr;
}
/*
 * 串口0发送数据函数
 */
void Send_Byte(unsigned char data)
{
  while(!(UCA1IFG & UCTXIFG));          //发送寄存器空的时候发送数据
      UCA1TXBUF=data;
}
/*
 * 串口0发送字符串函数
 */
void Print_Str(unsigned char *s)
{
    while(*s != '\0')
    {
        Send_Byte(*s++);
    }
}

void parseGpsBuffer()
{
    char *subString;
    char *subStringNext;
    char i = 0;
//    Print_Str(Save_Data.GPS_Buffer);
    if (Save_Data.isGetData)
    {
        Save_Data.isGetData = false;
        Print_Str("**************\r\n");
        Print_Str(Save_Data.GPS_Buffer);


        for (i = 0 ; i <= 6 ; i++)
        {
            if (i == 0)
            {
                if ((subString = strstr(Save_Data.GPS_Buffer, ",")) == NULL)
                    error();    //解析错误
            }
            else
            {
                subString++;
                if ((subStringNext = strstr(subString, ",")) != NULL)
                {
                    char usefullBuffer[2];
                    switch(i)
                    {
                        case 1:memcpy(Save_Data.UTCTime, subString, subStringNext - subString);break;   //获取UTC时间
                        case 2:memcpy(usefullBuffer, subString, subStringNext - subString);break;   //获取UTC时间
                        case 3:memcpy(Save_Data.latitude, subString, subStringNext - subString);break;  //获取纬度信息
                        case 4:memcpy(Save_Data.N_S, subString, subStringNext - subString);break;   //获取N/S
                        case 5:memcpy(Save_Data.longitude, subString, subStringNext - subString);break; //获取经度信息
                        case 6:memcpy(Save_Data.E_W, subString, subStringNext - subString);break;   //获取E/W

                        default:break;
                    }

                    subString = subStringNext;
                    Save_Data.isParseData = true;
                    if(usefullBuffer[0] == 'A')
                        Save_Data.isUsefull = true;
                    else if(usefullBuffer[0] == 'V')
                        Save_Data.isUsefull = false;

                }
                else
                {
                    error();    //解析错误
                }
            }


        }
    }
}
void printGpsBuffer()
{
    if (Save_Data.isParseData)
    {
        Save_Data.isParseData = false;

        Print_Str("Save_Data.UTCTime = ");
        Print_Str(Save_Data.UTCTime);
        Print_Str("\r\n");

        if(Save_Data.isUsefull)
        {
            Save_Data.isUsefull = false;
            Print_Str("Save_Data.latitude = ");
            Print_Str(Save_Data.latitude);
            Print_Str("\r\n");


            Print_Str("Save_Data.N_S = ");
            Print_Str(Save_Data.N_S);
            Print_Str("\r\n");

            Print_Str("Save_Data.longitude = ");
            Print_Str(Save_Data.longitude);
            Print_Str("\r\n");

            Print_Str("Save_Data.E_W = ");
            Print_Str(Save_Data.E_W);
            Print_Str("\r\n");
        }
        else
        {
            Print_Str("GPS DATA is not usefull!\r\n");
        }

    }
}
void main(void)
{
    WDTCTL = WDTPW + WDTHOLD;  // 关闭看门狗
    init();              //初始化时钟与电子墨水屏接口
    Clock_Init();
//    initClock();
    P1DIR |= BIT0;

    P4SEL = BIT4+BIT5;         // P3.3和P3.4选择UART通信功能
    UCA1CTL1 |= UCSWRST;       // 复位寄存器设置
    UCA1CTL1 |= UCSSEL_1; // 波特率参考时钟设置为ACLK，ACLK=32768Hz
    UCA1BR0 = 0x03;            // 波特率设置为9600bps
    UCA1BR1 = 0x00;
    UCA1MCTL = UCBRS_3+UCBRF_0;// 调整器设置
    UCA1CTL1 &= ~UCSWRST;      // 完成USCI_A0初始化设置，关闭寄存器设置
    UCA1IE |= UCRXIE;          // USCI_A0接收中断使能
   Print_Str("Xiamen University \n");
    P1OUT |= BIT0;
    clrStruct();


    __bis_SR_register(LPM3_bits + GIE);  // 进入LPM3，并使能全局中断

}

//char USART_RX_BUF[USART_REC_LEN];
//int point1=0;
// USCI_A0中断服务程序  //
#pragma vector=USCI_A1_VECTOR
__interrupt void USCI_A1_ISR(void)
{
  switch(__even_in_range(UCA1IV,4))
  {
      case 0: break;  // 中断向量0—无中断
      case 2:         // 中断向量2—接收中断
              //在这里写接收中断服务程序代码
        while (!(UCA1IFG & UCTXIFG));  // USCI_A0 是否发送完成
        if(UCA1RXBUF == '$')
                   {
                       point1 = 0;

                   }
        USART_RX_BUF[point1++] = UCA1RXBUF;
        if(USART_RX_BUF[0] == '$' && USART_RX_BUF[4] == 'M' && USART_RX_BUF[5] == 'C')          //确定是否收到"GPRMC/GNRMC"这一帧数据
        {
            if(UCA1RXBUF == '\n')
            {
                        memset(Save_Data.GPS_Buffer, 0, GPS_Buffer_Length);      //清空
                        memcpy(Save_Data.GPS_Buffer, USART_RX_BUF, point1);     //保存数据
                        Save_Data.isGetData = true;
                        memset(USART_RX_BUF, 0, USART_REC_LEN);
  //                     Print_Str(Save_Data.GPS_Buffer);
                        point1 = 0;
            }

        }
//
        parseGpsBuffer();
//        printGpsBuffer();
        displayGpsBuffer();
        if(point1 >= USART_REC_LEN)
        {
            point1 = USART_REC_LEN;
        }
//      UCA1TXBUF = UCA1RXBUF;     // 将接收缓冲寄存器的字符传送给发送缓冲寄存器，发送给PC，在串口调试助手中回显。
        break;
      case 4:         // 中断向量4—发送中断
               //在这里写发送中断服务程序代码
        break;
      default: break;
  }
}