关于利用超核HI600D获取UTC时间，经纬度，东经，地面速度，地面航向，日期。

已于 2023-09-19 21:07:26 修改
阅读量426 收藏 5
点赞数 7
文章标签： stm32 单片机 嵌入式硬件
于 2023-08-08 10:36:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljt2333/article/details/132154035
版权

        本文利用stm32f103vet6开发板＋超核HI600D获取一系列信息

1.串口数据

当我们用type-B的数据线连接超核600D，与电脑连接时，打开串口助手，会获取一系列的信息

如图所示：

 这是未定位的原始数据，我们想要得到有效数据，得在空旷环境或者在有基准站的地方进行定位。

定位后的数据如图：

我要读取的是RMC的信息

$GNRMC,044125.000,A,2951.1711260,N,11419.9958340,E,0.12,106.68,070823,,,A,V*03

这些数据为NMEA0183 V4.10 协议，如图可见

 GGA是接收机的时间、位置和定位相关数据。

 GSV是输出可视的卫星状态，包括：可视的卫星数、卫星标识号、仰角、方位角及信噪比（SNR）。

RMC是最简导航传输数据。（也是本文想要读取的数据并解析）

VTG输出地面速度信息。

主要为GGA，GSV，RMC。读者可根据自己的想要的数据来读取想要的NMEA协议，具体见HI600的用户手册。

2.stm32连接超核HI600D的使用

我是stm32f103vet6的开发板+HAL库开发，我也试过超核公司自己hi600的stm32代码，但是烧录进去串口一点反应都没有，可能是芯片型号不对或者是串口没有配置好，官方例程是stm32f103zet6+标准库开发，使用的是串口一和串口二，我是使用的串口一和串口三，将HI600连接到stm32的串口三。

    超核600连线stm32
  TX0        ————>PB11
  RX0————>PB10
 GND————>GND        
 5V————>

5V

                                                        如图为连线方式

2.1 配置串口

void USART1_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
   
		
	__HAL_RCC_USART1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();	
	  
    Usart_ISR.U1TXOver = Tx_Over;   	   
    Usart_ISR.U1RXOperation = RxFunction;  

    GPIO_InitStruct.Pin = GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
		
	huart1.Instance = USART1;
    huart1.Init.BaudRate = BPS;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart1) != HAL_OK)
    {
      Error_Handler();
    }
		
	__HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);  

	 
    HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
	HAL_NVIC_EnableIRQ(USART1_IRQn);
}
void USART3_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
	 GPIO_InitTypeDef GPIO_InitStruct = {0};
 
	 __HAL_RCC_USART3_CLK_ENABLE();
     __HAL_RCC_GPIOB_CLK_ENABLE();		
	 
     Usart_ISR.U3TXOver = Tx_Over;   	   
	 Usart_ISR.U3RXOperation = RxFunction;  
		
	GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
		
	huart3.Instance = USART3;
    huart3.Init.BaudRate = BPS;
    huart3.Init.WordLength = UART_WORDLENGTH_8B;
    huart3.Init.StopBits = UART_STOPBITS_1;
    huart3.Init.Parity = UART_PARITY_NONE;
    huart3.Init.Mode = UART_MODE_TX_RX;
    huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart3.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart3) != HAL_OK)
    {
     Error_Handler();
    }
		
	   __HAL_UART_ENABLE_IT(&huart3, UART_IT_RXNE);   

	 
	   HAL_NVIC_SetPriority(USART3_IRQn, 0, 1);
	   HAL_NVIC_EnableIRQ(USART3_IRQn);
	
}

配置好串口后可自己试验一下，串口三的数据能不能发送到串口一打印。

void ESP_RX_ISR( uint8_t RX_Data)
{
		
	esp_recv_buff[esp_rx_index++] = RX_Data;
}

因为我是改编8266的代码，所以有些函数的名字没有更改，抱歉，但本质内容不变，这这个函数中，我们获得了最重要的串口三的RX_Data,并存入了esp_recv_buff这个数组里面。

USART1_Send_Poll(esp_recv_buff,esp_recv_len);

void USART1_Send_Poll(uint8_t *buff, uint16_t Size) 
{
	uint16_t i;
	
	for(i = 0; i < Size; i++)
	{
		USART1_SendByte(*buff++);
	  
	}
}


void USART1_SendByte(char ch)
{	
	while((USART1_SR&UART_LSR_THRE)==0);	
	SEND_BUF1 = (u8) ch;
}

我们可以将这个esp_recv_buff发送至串口一打印出来，判断数据有没有存入。

void USART3_IRQHandler(void)
{	
	
	if(USART3_SR&UART_LSR_RDR)			
	{	  
 		if(Usart_ISR.U3RXOperation != NULL) Usart_ISR.U3RXOperation(RECV_BUF3); 	
      
	} 
	
	HAL_UART_IRQHandler(&huart3);

这里在主函数要添加一个中断函数，可以判断是否接收中。

void ESP_RecvProcess(void)
{		
	    USART1_Send_Poll(esp_recv_buff,esp_recv_len);
	    ProcessRx(esp_recv_buff,esp_recv_len);
	    ESP_RecvBuff_Clear();
	    HAL_Delay(1000);

}

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  SysTick_Init(systick_isr);
  USART1_Init(115200,NULL,NULL);
  HI600_Init();  
    while(1)
    {	
			ESP_RecvProcess();
    }
}

我们在主函数中初始化串口1和3，在循坏里面打印数据和解析数据。

注意在接收函数中，还有添加ESP_RecvBuff_Clear()函数和一个延时函数，帮助我们按时清空ESP_RecvBuff里面的数据，以防数组溢出。

当我们能正常打印串口3发送至串口1的数据时，我们就可以开始数据解析了

如图：

2.2数据解析

因为我想要读取的NMEA协议是RMC,首先我们查看RMC的输出数据格式

 可见报头的开始是$GPRMC

     //数据每一位的字符
     #define BEGIN1 '$'
     #define BEGIN2 'G'
     #define BEGIN3 'N'
     #define BEGIN4 'R'
     #define BEGIN5 'M'
     #define BEGIN6 'C'

    uint8_t receivedbyte, rx_sum, command;
    uint8_t rx_data[100];
    uint16_t rx_dategram_len;
    while (size)
    {
        switch (rx_datagram_state)
        {
        case IDLE:
        {   int i=1;
					//printf("%s",buff);
					 token=strchr((char*)buff,B);
					*buff=*token;
					while(i)
					{
							receivedbyte = *buff;
            if (BEGIN1 == receivedbyte)
            {
              //  printf("HEADER1:%c\r\n", *buff);
                rx_sum = 0;
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER1;
                buff++;
							  i=0;
            }
						else
						{
							buff++;
						}
					}
            break;
        }
        case SEEN_HEADER1: 
        {
            receivedbyte = *buff;
            if (BEGIN2 == receivedbyte)
            {
            //   printf("HEADER2:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER2;
                buff++;
            }
            break;
        }
				 case SEEN_HEADER2: 
        {  
					
					int i=1;
          while(i)  
					{
						receivedbyte = *buff;
            if (BEGIN3 == receivedbyte)
            {
            //  printf("HEADER3:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER3;
                buff++;
			    i=0;
                }
				else{
				buff++;
						}
					}
                break;
                }
				 case SEEN_HEADER3: //
                {    
					
					  int i=1;
            while(i)  
					{
						receivedbyte = *buff;
            if (BEGIN4 == receivedbyte)
            {
             //  printf("HEADER4:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER4;
                buff++;
			    i=0;
            }
			    else{
				buff++;
					}
					}
            break;
        }
				 case SEEN_HEADER4: //
        {  
					
					 int i=1;
           while(i)  
					{
						receivedbyte = *buff;
            if (BEGIN5 == receivedbyte)
            {
            //   printf("HEADER5:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER5;
                buff++;
							  i=0;
            }
						else{
								buff++;
						}
					}
            break;
        }
				 case SEEN_HEADER5: //
        {
           int i=1;  
					
					while(i)  
					{
				receivedbyte = *buff;
            if (BEGIN6 == receivedbyte)
            {
            //   printf("HEADER6:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER6;
                buff++;
			  i=0;
            }
			else{
			buff++;
				}
			    }
            break;
           }
				 case SEEN_HEADER6: //
           {
            receivedbyte = *buff;
            if (BEGIN7 == receivedbyte)
            {
            //   printf("HEADER7:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER7;
                buff++;
            }
            break;
        }

后面便是我们的第一个数据UTC时间，这里注意UTC时间不是北京时间！！！（多谢超核公司的熙熙提醒，因为我当时还在群里问了）

 case SEEN_HEADER7: 
        {
           uint8_t  TIME[11];
           for(int i=0;i<=10;i++)
					{
						TIME[i]=*buff++;
						
					}
                      UTC.Hour[0]=TIME[0];
					  UTC.Hour[1]=TIME[1];
					  UTC.Minute[0]=TIME[2];
				      UTC.Minute[1]=TIME[3];
				      UTC.Sconds[0]=TIME[4];
					  UTC.Sconds[1]=TIME[5];
					  UTC.mSconds[0]=TIME[7];
					  UTC.mSconds[1]=TIME[8];
					  UTC.mSconds[2]=TIME[9];
					  printf("UTC时间为：%c%c:%c%c:%c%c\r\n",UTC.Hour[0],UTC.Hour[1],UTC.Minute[0],UTC.Minute[1],UTC.Sconds[0],UTC.Sconds[1]);
					  //printf("TIME=%s",TIME); 
                rx_datagram_state = SEEN_HEADER8;
					 // buff++;
					  break;
        }

OS：如果有想要北京时间的读者，可以自己查询UTC时间转换北京时间的算法，这里就不另外介绍了。

        case SEEN_HEADER8: //读A
        {
            receivedbyte = *buff;
            if (BEGIN9 == receivedbyte)
            {
             //   printf("HEADER8:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER9;
                buff++;
            }
            break;
        }

这里是RMC最重要的一个地位，毕竟这里是判断是有效定位还是无效定位的地方，如果是A就代表有效定位，如果是V就代表无效定位。

     case SEEN_HEADER9: 
        {
            receivedbyte = *buff;
            if (BEGIN7 == receivedbyte)
            {
              //  printf("HEADER9:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER10;
                buff++;
            }
            break;
        }

这个是一个读逗号的判断，如果不想判断，可以在读A的代码中，在break的前面加上buff++，这样可以不用读逗号，但我为了准确性，还是判断了每一位逗号。

case SEEN_HEADER10: 
        {
           uint8_t  TIME[12];
           for(int i=0;i<=11;i++)
					{
					TIME[i]=*buff++;
						
					}
                    lat.Hour[0]=TIME[0];
					lat.Hour[1]=TIME[1];
					lat.divide[0]=TIME[2];
				    lat.divide[1]=TIME[3];
				    lat.mSconds[0]=TIME[5];
				  	lat.mSconds[1]=TIME[6];
					lat.mSconds[2]=TIME[7];
					lat.mSconds[3]=TIME[8];
				    lat.mSconds[4]=TIME[9];
				    lat.mSconds[5]=TIME[10];
					lat.mSconds[6]=TIME[11];
				    printf("纬度: %c%c¡ã%c%c.%c%c%c%c%c%c%c\r\n",TIME[0],TIME[1],TIME[2],TIME[3],TIME[5],TIME[6],TIME[7],TIME[8],TIME[9],TIME[10],TIME[11]);
            rx_datagram_state = SEEN_HEADER11;
					 // buff++;
					  break;
        }
				case SEEN_HEADER11: //
        {
            receivedbyte = *buff;
            if (BEGIN7 == receivedbyte)
            {
             //   printf("HEADER9:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER12;
                buff++;
            }
            break;
        }
				
				case SEEN_HEADER12: 
        {
            receivedbyte = *buff;
            if (BEGIN3 == receivedbyte)
            {
           //     printf("HEADER10:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER13;
                buff++;
            }
					//	buff++;
            break;
        }
//				
				case SEEN_HEADER13: 
        {
            receivedbyte = *buff;
            if (BEGIN7 == receivedbyte)
            {
             //   printf("HEADER11:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER14;
                buff++;
            }
            break;
        }

				case SEEN_HEADER14: 
        {
           uint8_t  TIME[13];
           for(int i=0;i<=12;i++)
					{
						TIME[i]=*buff++;
						
					}
            lon.Hour[0]=TIME[0];
					  lon.Hour[1]=TIME[1];
					  lon.Hour[2]=TIME[2];
					  lon.divide[0]=TIME[3];
					  lon.divide[1]=TIME[4];
				      lon.mSconds[0]=TIME[6];
				  	  lon.mSconds[1]=TIME[7];
					  lon.mSconds[2]=TIME[8];
					  lon.mSconds[3]=TIME[9];
					  lon.mSconds[4]=TIME[10];
					  lon.mSconds[5]=TIME[11];
					  lon.mSconds[6]=TIME[12];
					  printf("经度: %c%c%c¡ã%c%c.%c%c%c%c%c%c%c\r\n",TIME[0],TIME[1],TIME[2],TIME[3],TIME[4],TIME[6],TIME[7],TIME[8],TIME[9],TIME[10],TIME[11],TIME[12]);
            rx_datagram_state = SEEN_HEADER15;
					 // buff++;
					  break;
        }
				
				case SEEN_HEADER15: 
        {
            receivedbyte = *buff;
            if (BEGIN7 == receivedbyte)
            {
            //    printf("HEADER9:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER16;
                buff++;
            }
            break;
        }
				case SEEN_HEADER16: 
        {
            receivedbyte = *buff;
            if (BEGIN11 == receivedbyte)
            {
                printf("东航:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER17;
                buff++;
            }
					
            break;
         }
				
				case SEEN_HEADER17: 
          {
             receivedbyte = *buff;
            if (BEGIN7 == receivedbyte)
            {
             //   printf("HEADER11:%c\r\n", *buff);
                rx_sum += receivedbyte;
                rx_datagram_state = SEEN_HEADER18;
                buff++;
            }
            break;
        }
//				
				case SEEN_HEADER18: 
        {
           uint8_t  TIME[5];
           for(int i=0;i<=4;i++)
					{
						TIME[i]=*buff++;
						
					}
                    GS.Hour[0]=TIME[0];					
				    GS.mSconds[0]=TIME[2];
				  	GS.mSconds[1]=TIME[3];
					//	GS.mSconds[2]=TIME[4];
				  printf("地面速度%c.%c%c\r\n",TIME[0],TIME[2],TIME[3]);
                    rx_datagram_state = SEEN_HEADER19;
					  break;
        }

				case SEEN_HEADER19: 
        {
                 uint8_t  TIME[6];
                 for(int i=0;i<=5;i++)
					{
						TIME[i]=*buff++;
						
					}
                   GH.Hour[0]=TIME[0];	
				  	GH.Hour[1]=TIME[1];	
				  	//GH.Hour[2]=TIME[2];	
				    GS.mSconds[0]=TIME[3];
				  	GS.mSconds[1]=TIME[4];
				  printf("地面航向%c%c.%c%c\r\n",TIME[0],TIME[1],TIME[3],TIME[4]);
            rx_datagram_state = SEEN_HEADER20;
					  break;
        }

后面的数据也是同理可得，不过得细心判断，不然就会出错

case SEEN_HEADER20: 
        {
           uint8_t  TIME[6];
           for(int i=0;i<=5;i++)
					{
						TIME[i]=*buff++;
						
					}
            date.YEAR[0]=TIME[0];	
				  	date.YEAR[1]=TIME[1];	
				  	date.Mon[0]=TIME[2];	
				    date.Mon[1]=TIME[3];
					  date.DAY[0]=TIME[4];
				  	date.DAY[1]=TIME[5];
					printf("日期:%c%c.%c%c.%c%c\r\n",TIME[4],TIME[5],TIME[2],TIME[3],TIME[0],TIME[1]);
            rx_datagram_state = SEEN_HEADER21;
					  break;
        }

				
        case SEEN_HEADER21: 
        {
            command = *buff; 
            rx_sum += command;
            rx_datagram_state = SEEN_COMMAND;
			  printf("data over!");
             //printf("SEEN_COMMAND:%x\r\n", command);
            buff++;
        }
        break;

这个地方日期要注意，因为它是反着来的，例如今天是070823，第一次正着读还以为是信息问题，经官方工作人员熙熙的提醒后，明白了这个数据是23年08月07日。后面的数据暂时不需要我就停止了解析。

最后结果：

总结：

1.串口3发送至串口1时要多调试，不然很有可能读取的时候，打开串口啥也没有。

2.解析的过程中要有耐心，注意buff的顺序，不然很有可能读错位或者数据不显示。

3.后续可以把UTC时间转换成北京时间，添加算法函数即可。

4.只解析了一个RMC的信息，可以多写一些解析函数，将GGA，GSV也解析出来。

ljt2333
关注
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值