如何使GPS的經緯度實時刷新(1秒刷新1次)附單片機程序

我在網上找了一些解析GPS的程序，并用OLED顯示出來。目前可以做到解析和顯示，但做不到實時刷新。請高手指點一下。謝謝
IIC的程序就不貼出來了。
單片機源程序如下:

1. #include <reg51.h>
   
2. #include "iic_oled.h"
   
3. 
   
4. 
   
5. #define u8 unsigned char
   
6. #define u16 unsigned int
   
7. #define u32 unsigned long
   
8. 
   
9. u8 RX_Buffer[68];                //此數組用于直接儲存來自GPS的原始數據
   
10. u8 RX_Count = 0;
    
11. //u8 Hour = 0,Min_High = 0,Min_Low = 0,Sec_High = 0,Sec_Low = 0;
    
12. u8 Month = 0,Day = 0,Month_High = 0, Month_Low = 0,Day_Low = 0 ,Day_High = 0, Year_High = 0,Year_Low = 0;
    
13. u16 Year = 0;
    
14. bit Flag_GPS_OK = 0;
    
15. u8 MaxDay = 0;
    
16. 
    
17. 
    
18. u8 xdata Display_GPGGA_Buffer[68]={0};                //用于儲存GPGGA的數據
    
19. 
    
20. 
    
21. 
    
22. 
    
23. bit Flag_Calc_GPGGA_OK = 0;           //GPGGA完整有效的數據已收到的標志變量
    
24. 
    
25. 
    
26. void Uart_Init();
    
27. u8 GetMaxDay(u8 Month_Value,u16 Year_Value);
    
28. bit IsLeapYear(u16 uiYear);
    
29. void Delay500ms()        ;
    
30. 
    
31. 
    
32. 
    
33. //****************************************************
    
34. //主函數
    
35. //****************************************************
    
36. void main()
    
37. {
    
38.         u16 i = 0;
    
39. 
    
40.         Uart_Init();                                                                        //串口初始化
    
41.         OLED_Init();//初始化OLED
    
42.   OLED_Clear();//清屏
    
43. 
    
44.         while(1)
    
45.         {
    
46. 
    
47. 
    
48. 
    
49.                 if (   Flag_GPS_OK  == 1         && RX_Buffer[4] == 'G'
    
50.                         && RX_Buffer[6] == ','   && RX_Buffer[13] == '.'
    
51.                     )                //確認是否收到"GPGGA"這一幀完整有效的數據
    
52.                 {
    
53.                         for( i = 0; i < 67 ; i++)                                                  //必須為i<67，因為要確保Display_GPGGA_Buffer[67]為'\0',便于串口發送
    
54.                         {
    
55.                                 Display_GPGGA_Buffer[i] = RX_Buffer[i];                  //儲存到數組中
    
56.                         }
    
57.                         Flag_Calc_GPGGA_OK = 1;                                                          //收到完整有效數據后，置為1
    
58.                         
    
59.                 }
    
60.                 if(Display_GPGGA_Buffer[28] == 'N')
    
61.                 {
    
62.                 OLED_ShowChar(0, 0, 'G');
    
63.                 OLED_ShowChar(8, 0, 'P');
    
64.                 OLED_ShowChar(16, 0, 'S');
    
65.                 OLED_ShowChar(24, 0, ':');
    
66.                         
    
67.                 OLED_ShowChar(0, 2, Display_GPGGA_Buffer[28]);//N
    
68.                 OLED_ShowChar(8, 2, ':'); //:
    
69.                 OLED_ShowChar(16, 2, Display_GPGGA_Buffer[17]);               
    
70.                 OLED_ShowChar(24, 2, Display_GPGGA_Buffer[18]);
    
71.                 OLED_ShowChar(32, 2, 127);               
    
72.                 OLED_ShowChar(40, 2, Display_GPGGA_Buffer[19]);
    
73.                 OLED_ShowChar(48, 2, Display_GPGGA_Buffer[20]);        
    
74.                 OLED_ShowChar(56, 2, '.');        
    
75.                 OLED_ShowChar(64, 2, Display_GPGGA_Buffer[22]);        
    
76.                 OLED_ShowChar(72, 2, Display_GPGGA_Buffer[23]);                        
    
77.                 OLED_ShowChar(80, 2, Display_GPGGA_Buffer[24]);                        
    
78.                 OLED_ShowChar(88, 2, Display_GPGGA_Buffer[25]);                        
    
79.                 OLED_ShowChar(96, 2, Display_GPGGA_Buffer[26]);                                
    
80.                 OLED_ShowChar(104, 2, 39);               
    
81.                
    
82.                 OLED_ShowChar(0, 4, Display_GPGGA_Buffer[42]);//E
    
83.                 OLED_ShowChar(8, 4, ':'); //:
    
84.                 OLED_ShowChar(16, 4, Display_GPGGA_Buffer[30]);               
    
85.                 OLED_ShowChar(24, 4, Display_GPGGA_Buffer[31]);
    
86.           OLED_ShowChar(32, 4, Display_GPGGA_Buffer[32]);
    
87.                 OLED_ShowChar(40, 4, 127);               
    
88.                 OLED_ShowChar(48, 4, Display_GPGGA_Buffer[33]);
    
89.                 OLED_ShowChar(56, 4, Display_GPGGA_Buffer[34]);        
    
90.                 OLED_ShowChar(64, 4, '.');        
    
91.                 OLED_ShowChar(72, 4, Display_GPGGA_Buffer[36]);        
    
92.                 OLED_ShowChar(80, 4, Display_GPGGA_Buffer[37]);                        
    
93.                 OLED_ShowChar(88, 4, Display_GPGGA_Buffer[38]);                        
    
94.                 OLED_ShowChar(96, 4, Display_GPGGA_Buffer[39]);                        
    
95.                 OLED_ShowChar(104, 4, Display_GPGGA_Buffer[40]);                                
    
96.                 OLED_ShowChar(112, 4, 39);        
    
97.         }
    
98.                 else
    
99.                 {
    
100.                 OLED_ShowChar(0, 0, 'G');
     
101.                 OLED_ShowChar(8, 0, 'P');
     
102.                 OLED_ShowChar(16, 0, 'S');
     
103.                 OLED_ShowChar(24, 0, ':');
     
104. 
     
105.                 OLED_ShowChar(0, 2, 'n');//N
     
106.                 OLED_ShowChar(8, 2, 'o'); //:
     
107.                 OLED_ShowChar(16, 2, 't');               
     
108.                 OLED_ShowChar(24, 2, 32);
     
109.                 OLED_ShowChar(32, 2, 'c');               
     
110.                 OLED_ShowChar(40, 2, 'o');
     
111.                 OLED_ShowChar(48, 2, 'n');        
     
112.                 OLED_ShowChar(56, 2, 'n');        
     
113.                 OLED_ShowChar(64, 2, 'e');        
     
114.                 OLED_ShowChar(72, 2, 'c');                        
     
115.                 OLED_ShowChar(80, 2, 't');                        
     
116.                 OLED_ShowChar(88, 2, 32);                        
     
117.                 OLED_ShowChar(96, 2, 32);                                
     
118.                 OLED_ShowChar(104, 2, 32);               
     
119.                
     
120.                 OLED_ShowChar(0,4, 32);//E
     
121.                 OLED_ShowChar(8,4, 32); //:
     
122.                 OLED_ShowChar(16,4, 32);               
     
123.                 OLED_ShowChar(24,4, 32);
     
124.           OLED_ShowChar(32,4, 32);
     
125.                 OLED_ShowChar(40,4, 32);               
     
126.                 OLED_ShowChar(48,4, 32);
     
127.                 OLED_ShowChar(56,4, 32);        
     
128.                 OLED_ShowChar(64,4, 32);        
     
129.                 OLED_ShowChar(72,4, 32);        
     
130.                 OLED_ShowChar(80,4, 32);                        
     
131.                 OLED_ShowChar(88,4, 32);                        
     
132.                 OLED_ShowChar(96,4, 32);                        
     
133.                 OLED_ShowChar(104,4, 32);                                
     
134.                 OLED_ShowChar(112,4, 32);
     
135.                
     
136.                 }
     
137.                
     
138.         }
     
139. }
     
140. 
     
141. 
     
142. 
     
143. void Uart_Init()                                                                     
     
144. {
     
145.         SCON = 0X50;  //UART方式1；8位UART
     
146.         REN  = 1;     //允許串行口接收數據
     
147.         PCON = 0x00;  //SMOD=0;波特率不加倍
     
148.         TMOD = 0x20;  //T1方式2，用于產生波特率
     
149.         TH1  = 0xFD;  //裝初值
     
150.         TL1  = 0xFD;
     
151.         TR1  = 1;     //啟動定時器1
     
152.         EA   = 1;     //打開全局中斷控制
     
153.         ES   = 1;     //打開串行口中斷        
     
154. }
     
155. 
     
156. 
     
157. void RECEIVE_DATA(void) interrupt 4 using 3                  //串口中斷函數，收到GPS的數據時進入此中斷        
     
158. {
     
159.         u8 temp = 0;
     
160.         ES=0;                //先關閉串行口中斷
     
161. if(RI)
     
162. {        
     
163.         temp = SBUF;                                                                //接收SBUF中的數據
     
164.         if(temp == '
     
165. 
     
166. )                                                                //若是統一的數據頭，則作為數組第一個元素
     
167.         {
     
168.                 RX_Count = 0;
     
169.                 Flag_GPS_OK = 0;               
     
170.         }
     
171. 
     
172.         RX_Buffer[RX_Count++] = temp;                                //收到的數據放到數組中
     
173. 
     
174.         if(RX_Count >= 66)                                                        //序號大于66的數據無用，統一放到第66位覆蓋掉
     
175.         {
     
176.                 RX_Count = 66;
     
177.         }
     
178. 
     
179.         if(temp == '*')                                                                //收到*，則完成一幀數據的接收，不管是否完整有效
     
180.         {
     
181.                 Flag_GPS_OK = 1;                                                //標志變量置為1
     
182.         }
     
183. }
     
184.         RI = 0;                                                                                //接收完成的標志位清零
     
185.         ES=1;                                                                                 //重新打開串行口中斷
     
186. 
     
187. }
     
188. 
     

復制代碼

全部資料51hei下載地址：
改版.rar (57.14 KB, 下載次數: 16)

2021-9-1 23:24 上傳

點擊文件名下載附件

將接收緩存RX_Buffer改成環形緩存LOOP_Buffer，即串口中斷每次按字節寫入環形緩存中。新增緩存數組GPS_Buffer，while(1)循環體遍歷按字節取出LOOP_Buffer的數據存儲到GPS_Buffer中，并判斷是否完幀，最后OLED顯示。

a1093941419 發表于 2021-9-2 09:43
將接收緩存RX_Buffer改成環形緩存LOOP_Buffer，即串口中斷每次按字節寫入環形緩存中。新增緩存數組GPS_Buff ...

或者更簡單的說，程序應該設計成串口中斷一邊接收，主體部分一邊解析，而不是等到串口都接收完成再去解析。

我這兩天也是在搞這上GPS,數據有點多,不過也是慢慢的理清了
定義一個結構體
串口中斷一邊接收,主函數一邊處理數據
串口接收到一幀的完整數據之后,直接用結構體復制過來,感覺比數組好用
struct                                                           //GPS_Buffer結構
{
char GPS_Buffer[80];                                //留80個地址來存放GPS的數據
}xdata GPS_Buffer0,GPS_Buffer1;                 //兩個結構變量,讓串口接收和保存不相互影響

GPS_Buffer1=GPS_Buffer0; //這個是在串口中斷中完成的

在主函數中把GPS_Buffer1結構體中的數據提取出來處理就可以了,先處理好數據,時間一到就刷新

a1093941419 發表于 2021-9-2 10:04
或者更簡單的說，程序應該設計成串口中斷一邊接收，主體部分一邊解析，而不是等到串口都接收完成再去解析 ...

你這樣說，感覺有點明白了。晚上回去試試。我的理解是給中斷一個數組（目前程序中的RX_Buffer），讓他存串口接收到的數據；然后再while(1)里面再給一個數組LOOP_Buffer。當RX_Buffer接收完數據后，再把RX_Buffer數據給LOOP_Buffer。

Y_G_G 發表于 2021-9-2 10:36
我這兩天也是在搞這上GPS,數據有點多,不過也是慢慢的理清了
定義一個結構體
串口中斷一邊接收,主函數一邊 ...

謝謝回復。你這個說法似乎和你的樓上說的差不多。我的理解是給中斷一個數組（目前程序中的RX_Buffer），讓他存串口接收到的數據；然后再while(1)里面再給一個LOOP_Buffer，當RX_Buffer接收完數據后，再把RX_Buffer數據給LOOP_Buffer。

川人在柳 發表于 2021-9-2 12:40
謝謝回復。你這個說法似乎和你的樓上說的差不多。我的理解是給中斷一個數組（目前程序中的RX_Buffer）， ...

我這個是懶人做法,GPS_Buffer1始終保存的是上一幀數據,不用檢測什么接收完成沒有
GPS_Buffer0在中斷中完成后自動把數據復制到GPS_Buffer1
用結構的好處就是可以直接GPS_Buffer1=GPS_Buffer0

a1093941419 發表于 2021-9-2 09:43
將接收緩存RX_Buffer改成環形緩存LOOP_Buffer，即串口中斷每次按字節寫入環形緩存中。新增緩存數組GPS_Buff ...

自己晚上試了一下，沒有搞定。感覺還是不能特別理解你講的內容。

Y_G_G 發表于 2021-9-2 19:52
我這個是懶人做法,GPS_Buffer1始終保存的是上一幀數據,不用檢測什么接收完成沒有
GPS_Buffer0在中斷中完 ...

能開源一下你的關于GPS數據解析的代碼么

川人在柳 發表于 2021-9-3 11:30
能開源一下你的關于GPS數據解析的代碼么

我在現在也是還在調試中
我接收的信息是最簡的GPS定位信息      $GNRMC

Uart_Isr() interrupt 4    串口中斷函數負責接收GPS數據和保存,接收到一個幀的數據就保存

GPS_Data_Disp()   這個函數是負責把GPS_Buffer1.GPS_Buffer[] 中的GPS相關信息提取出來的,因為室內沒有GPS信號,找了ATGM336H-5N數據手冊上數據進行調試,因為數據手冊上給我數據并不是完整的$GNRMC幀信息,考慮到會亂碼,所以,在讀取數組的時候是用++a這種形式去讀取的
調試好之后,有了完整的GPS信息,可以直接指定GPS_Buffer1.GPS_Buffer[] 數組位置進行讀取,代碼就沒有那么亂了

其實這個東西沒那么難的
1,先保證串口程序是一定正確的,這個好反復驗證,不能仿真,以實際開發板結果為準,有時候串口出問題,接收一兩字節就沒有問題,接收多了就有問題
2,串口接收到   $GNRMC  或者你自己想要的字符之后,就開始保存,不然就不用保存
3,GPS信息是以ASCII字符發送的,不是字符串,是字符,比如5,串口接收到的數據就是'5',也就是53
$GNRMC,084852.000,A,2236.9453,N,11408.4790,E,0.53,292.44,141216,,,A*7
5

以上的信息就是一幀的信息,逗號,小數點,*都是
調試的時候可以檢測','就是逗號,數據是以逗號分隔
你可以數相關信息在什么位置,也可以檢測逗號來提取
我這個代碼也可以用,可以接收和提取GPS信息,試了一下,GPS的經緯度定位基本就是我這樓位置,一般來說,GPS定位準確了,就可以認為其它的信息也是準確的了 uart.rar (1.81 KB, 下載次數: 18)

2021-9-3 22:51 上傳

點擊文件名下載附件

樓主：4g模塊用的是什么樣的?