串口中断接收与环形缓冲实例（apollo3 blue plus）
#define DEV_UART1 1
#define GPS_POWER_PIN 13
#define GPS_LOG_ENABLE 1
#define MAX_UART1_SIZE 1024
#define AM_BSP_GPIO_COM_UART1_TX 8
#define AM_BSP_GPIO_COM_UART1_RX 9
// 定义环形缓冲区结构
typedef struct
{
uint8_t RxBuffer[MAX_UART1_SIZE];
volatile uint16_t head; // 写指针（由中断回调修改）
volatile uint16_t tail; // 读指针（由主任务修改）
uint8_t ready;
} RingBuffer;
typedef struct
{
uint8_t TxBuffer[MAX_UART1_SIZE];
}uart1_dev_t;
typedef struct
{
uint8_t position_flag;
uint8_t printf_enable;
uint8_t status;
char time_hour[6];
char time_date[6];
char latitude[17];
char longitude[17];
float gps_latitude;
float gps_longitude;
}Gps_Module_Data;
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include "am_mcu_apollo.h"
#include "am_bsp.h"
#include "am_util.h"
#include <string.h>
#include "FreeRTOSConfig.h"
#include "dev_gps.h"
#include "FreeRTOS.h"
#include "task.h"
#include "time.h"
#include "queue.h"
#include "ble_app.h"
void *uart1_dev_Handle;
uart1_dev_t uart1_dev;
void *g_pvUART1;
TaskHandle_t gps_task_thread;
Gps_Module_Data gps_module_data;
static RingBuffer uart1_rx = {0};
//*****************************************************************************
//
// Configuration options
//
//*****************************************************************************
const am_hal_gpio_pincfg_t g_AM_BSP_GPIO_COM_UART1_TX =
{
.uFuncSel = AM_HAL_PIN_8_UART1TX,
.eDriveStrength = AM_HAL_GPIO_PIN_DRIVESTRENGTH_2MA
};
const am_hal_gpio_pincfg_t g_AM_BSP_GPIO_COM_UART1_RX =
{
.uFuncSel = AM_HAL_PIN_9_UART1RX
};
//*****************************************************************************
//
// init uart1 defualt
//
//*****************************************************************************
void dev_uart1_gpio_config_defualt(void)
{
g_pvUART1=NULL;
am_hal_gpio_pinconfig(AM_BSP_GPIO_COM_UART1_TX, g_AM_HAL_GPIO_DISABLE);
am_hal_gpio_pinconfig(AM_BSP_GPIO_COM_UART1_RX, g_AM_HAL_GPIO_DISABLE);
}
//*****************************************************************************
//
// deinit uart1
//
//*****************************************************************************
void dev_uart1_deinit(void)
{
am_hal_uart_tx_flush(g_pvUART1);
__NVIC_DisableIRQ((IRQn_Type)(UART0_IRQn + DEV_UART1));
am_hal_uart_power_control(g_pvUART1, AM_HAL_SYSCTRL_DEEPSLEEP, false);
am_hal_uart_deinitialize(g_pvUART1);
dev_uart1_gpio_config_defualt();
}
//*****************************************************************************
//
// read uart1 data
//
//*****************************************************************************
uint32_t dev_uart1_read_buf(uint8_t *data)
{
uint32_t ui32BytesRead;
am_hal_uart_transfer_t sRead =
{
.ui32Direction = AM_HAL_UART_READ,
.pui8Data = data,
.ui32NumBytes = 23,
.ui32TimeoutMs = 0,
.pui32BytesTransferred = &ui32BytesRead,
};
am_hal_uart_transfer(g_pvUART1, &sRead);
return ui32BytesRead;
}
//*****************************************************************************
//
// uart1 send data
//
//*****************************************************************************
void dev_uart1_send(uint8_t *data,uint32_t len)
{
am_hal_uart_transfer_t sWrite =
{
.ui32Direction = AM_HAL_UART_WRITE,
.pui8Data = data,
.ui32NumBytes = len,
.ui32TimeoutMs = AM_HAL_UART_WAIT_FOREVER,
.pui32BytesTransferred = 0,
};
am_hal_uart_transfer(g_pvUART1, &sWrite);
// am_util_debug_printf("uart send\r\n");
}
//*****************************************************************************
//
// 注册串口1中断回调函数
//
//*****************************************************************************
void dev_uart1_register(dev_uart1_callback cb)
{
uart1_isr_status = cb;
}
//*****************************************************************************
//
// uart1 isr
//
//*****************************************************************************
void am_uart1_isr(void)
{
uint32_t ui32Status;
//
// Read the masked interrupt status from the UART.
//
am_hal_uart_interrupt_status_get(g_pvUART1, &ui32Status, true);
am_hal_uart_interrupt_clear(g_pvUART1, ui32Status);
am_hal_uart_interrupt_service(g_pvUART1, ui32Status, 0);
// am_util_debug_printf("uart1 isr Status=%d\r\n",ui32Status);
if(uart1_isr_status !=NULL)
uart1_isr_status(ui32Status);
}
void gps_power_gpio_init(void)
{
const am_hal_gpio_pincfg_t gps_pin =
{
.eDriveStrength = AM_HAL_GPIO_PIN_DRIVESTRENGTH_2MA,
.eGPOutcfg = AM_HAL_GPIO_PIN_OUTCFG_PUSHPULL,
.uFuncSel = 3 //GPIO功能
};
am_hal_gpio_pinconfig(GPS_POWER_PIN, gps_pin);
am_hal_gpio_output_set(GPS_POWER_PIN);
gps_module_data.status = 1;
}
/*
**将传入的字符串按照分隔符分隔开，如果两个分隔符中间没数据，返回\0
**函数返回值为分割之后，后面剩下的数据
**data:传入的字符串，control:分隔符，out_string:分隔符中间的数据
*/
char *cut_string(char *data,const char * control,char *out_string)
{
char *p1 = NULL;//
char *p2 = NULL;//
p1 = strstr(data,control);
if(p1==NULL)return NULL;
p2 = strstr(p1+1,control);
if(p2==NULL)return NULL;
if((p2-p1)==1)//
{
*out_string='\0';
data = p2;
}
else
{
memcpy(out_string,p1+1,(int)(p2-p1-1));//
*(out_string+(p2-p1-1))='\0';
data = p2;
}
return data;
}
//字符转换浮点数
static float parse_lat_long(char *str)
{
float ll = strtof(str, NULL);
int deg = ((int)ll) / 100;
float min = ll - (deg * 100);
ll = deg + min / 60.0f;
return ll;
}
//$GNRMC,100512.000,A,2232.3339,N,11401.5394,E,0.49,83.03,1 A * 54
static uint8_t gps_get_latitude_and_longitude(char *data)
{
char string[15]={0};
char *aaa = NULL;
uint8_t cnt = 0;
char *p1=NULL,*p2=NULL;
uint8_t ret = 0,valid = 0;
if(((p1=strstr(data,"RMC"))!=NULL)&&((p2=strstr(p1,"*"))!=NULL)&&(p2-p1<100))
{
aaa = p1;
while(aaa!=NULL)
{
cnt++;
aaa=cut_string(aaa,",",string);
if(aaa==NULL)break;
if(cnt == 1)//UTC（Coordinated Universal Time）时间，hhmmss（时分秒
{
memset(gps_module_data.time_hour,0,sizeof(gps_module_data.time_hour));
if((string[0]!=0)&&(strstr(string,".")!=NULL))
{
memcpy(gps_module_data.time_hour,string,6);
}
else
{
break;
}
}
else if((cnt == 2)&&(string[0]!=0))
{
//am_util_debug_printf("valid 0:%d",string[0]);
if(string[0] == 'A')
{
// gps_module_data.position_flag = 1;
valid = 1;
}
else
{
// gps_module_data.position_flag = 0;
valid = 0;
}
}
else if(cnt == 3)//纬度
{
memset(gps_module_data.latitude,0,sizeof(gps_module_data.latitude));
if((string[0]!=0)&&(strstr(string,".")!=NULL))
{
memcpy(gps_module_data.latitude+3,string,strlen(string));
}
else
{
break;
}
}
else if(cnt == 4)//N S
{
if(string[0] == 'S')
{
gps_module_data.latitude[0] = string[0];
gps_module_data.latitude[1] = ':';
gps_module_data.latitude[2] = '-';
if(GPS_LOG_ENABLE)am_util_debug_printf("latitude:%s\n",gps_module_data.latitude);
// gps_module_data.gps_latitude = parse_lat_long(&gps_module_data.latitude[2]);
// if(GPS_LOG_ENABLE)am_util_debug_printf("gps-latitude:%lf\n",gps_module_data.gps_latitude);
}
else if(string[0] == 'N')
{
gps_module_data.latitude[0] = string[0];
gps_module_data.latitude[1] = ':';
gps_module_data.latitude[2] = '0';
if(GPS_LOG_ENABLE)am_util_debug_printf("latitude:%s\n",gps_module_data.latitude);
// gps_module_data.gps_latitude = parse_lat_long(&gps_module_data.latitude[2]);
// if(GPS_LOG_ENABLE)am_util_debug_printf("gps-latitude:%lf\n",gps_module_data.gps_latitude);
}
else
{
break;
}
}
else if(cnt == 5)//经度
{
memset(gps_module_data.longitude,0,sizeof(gps_module_data.longitude));
if((string[0]!=0)&&(strstr(string,".")!=NULL))
{
memcpy(gps_module_data.longitude+3,string,strlen(string));
}
else
{
break;
}
}
else if(cnt == 6)//W E
{
if(string[0] == 'W')
{
gps_module_data.longitude[0] = string[0];
gps_module_data.longitude[1] = ':';
gps_module_data.longitude[2] = '-';
if(GPS_LOG_ENABLE)am_util_debug_printf("longitude:%s\n",gps_module_data.longitude);
// gps_module_data.gps_longitude = parse_lat_long(&gps_module_data.longitude[2]);
// if(GPS_LOG_ENABLE)am_util_debug_printf("gps-longitude:%lf\n",gps_module_data.gps_longitude);
}
else if(string[0] == 'E')
{
gps_module_data.longitude[0] = string[0];
gps_module_data.longitude[1] = ':';
gps_module_data.longitude[2] = '0';
if(GPS_LOG_ENABLE)am_util_debug_printf("longitude:%s\n",gps_module_data.longitude);
// gps_module_data.gps_longitude = parse_lat_long(&gps_module_data.longitude[2]);
// if(GPS_LOG_ENABLE)am_util_debug_printf("gps-longitude:%lf\n",gps_module_data.gps_longitude);
}
else
{
break;
}
}
else if(cnt == 7)//地面速率
{
}
else if(cnt == 8)//地面航向
{
}
else if(cnt == 9)//UTC日期，ddmmyy（日月年）格式
{
memset(gps_module_data.time_date,0,sizeof(gps_module_data.time_date));
if(string[0]!=0)
{
memcpy(gps_module_data.time_date,string,6);
struct tm lt; //C标准库time.h
int timezone = 0;
lt.tm_mday = (gps_module_data.time_date[0] - '0')*10 + (gps_module_data.time_date[1] - '0');
lt.tm_mon = (gps_module_data.time_date[2] - '0')*10 + (gps_module_data.time_date[3] - '0');
lt.tm_year = (gps_module_data.time_date[4] - '0')*10 + (gps_module_data.time_date[5] - '0');
lt.tm_hour = (gps_module_data.time_hour[0] - '0')*10 + (gps_module_data.time_hour[1] - '0');
lt.tm_min = (gps_module_data.time_hour[2] - '0')*10 + (gps_module_data.time_hour[3] - '0');
lt.tm_sec = (gps_module_data.time_hour[4] - '0')*10 + (gps_module_data.time_hour[5] - '0');
// gps time:211122095858
if(GPS_LOG_ENABLE)am_util_debug_printf("cclk:%d-%d-%d %d:%d:%d\n",lt.tm_mday,lt.tm_mon,lt.tm_year,lt.tm_hour,lt.tm_min,lt.tm_sec);
lt.tm_year = lt.tm_year + 100;
lt.tm_mon = lt.tm_mon - 1;
work.current_time = mktime(<)-(timezone/4*3600);
am_util_debug_printf("current_time : %lld",work.current_time); //北京时间
if(valid)
{
gps_module_data.gps_latitude = parse_lat_long(&gps_module_data.latitude[2]);
if(GPS_LOG_ENABLE)am_util_debug_printf("gps-latitude:%f\n",gps_module_data.gps_latitude);
gps_module_data.gps_longitude = parse_lat_long(&gps_module_data.longitude[2]);
if(GPS_LOG_ENABLE)am_util_debug_printf("gps-longitude:%f\n",gps_module_data.gps_longitude);
if(gps_module_data.position_flag == 0)
{
gps_module_data.position_flag = 1;
am_util_debug_printf("gps valid report\n");
}
ret = 1;
}
}
}
}
}
return ret;
}
void open_gps(void)
{
gps_module_data.status = 1;
gps_module_data.position_flag = 0;
am_hal_gpio_output_set(GPS_POWER_PIN);
vTaskResume(gps_task_thread);
am_util_debug_printf("gps task resume\n");
}
void close_gps(void)
{
if(gps_module_data.printf_enable == 1)return;
gps_module_data.status = 0;
gps_module_data.position_flag = 0;
am_hal_gpio_output_clear(GPS_POWER_PIN);
vTaskSuspend(gps_task_thread); //挂起UDP任务，直到解除挂起，
am_util_debug_printf("gps task suspend\n");
}
// 获取可读数据量 添加环形缓冲区辅助函数
uint32_t RingBuffer_Available(RingBuffer *rb)
{
uint32_t head = rb->head;
uint32_t tail = rb->tail;
if (head >= tail) return (head - tail);
return (MAX_UART1_SIZE - tail + head);
}
// 读取数据（在主任务中调用，带临界区保护）
uint8_t RingBuffer_Get(RingBuffer *rb)
{
__disable_irq();
if (rb->tail == rb->head)
{
__enable_irq();
return 0; // 无数据
}
uint8_t data = rb->RxBuffer[rb->tail];
rb->tail = (rb->tail + 1) % MAX_UART1_SIZE;
__enable_irq();
return data;
}
// 修改后的环形缓冲区写入函数（适配实际硬件）
static void RingBuffer_Put(RingBuffer *rb, uint8_t data)
{
uint32_t next_head = (rb->head + 1) % MAX_UART1_SIZE;
// 当缓冲区未满时写入
if (next_head != rb->tail)
{
rb->RxBuffer[rb->head] = data;
rb->head = next_head;
}
if (next_head == rb->tail)
{
am_util_debug_printf("--uart1 rx over--\n");// 处理缓冲区满的情况
}
}
//*****************************************************************************
//
// 串口1回调函数处理
//
//*****************************************************************************
void uart1_dev_receiver_handle(uint32_t ui32Status)
{
//am_util_debug_printf("reveier ui32Status=%d\r\n",ui32Status);
if (ui32Status & (AM_HAL_UART_INT_RX_TMOUT | AM_HAL_UART_INT_RX))
{
uint32_t i,totallen, ui32BytesRead = 0;
uint8_t temp_buf[64];
ui32BytesRead = dev_uart1_read_buf(temp_buf); //每次最多读23个字节
totallen = ui32BytesRead;
// 将数据写入环形缓冲区
for (i = 0; i < ui32BytesRead; i++)
{
RingBuffer_Put(&uart1_rx, temp_buf[i]);
}
//am_util_debug_printf("uart rx:%d\n",totallen);
if (ui32Status & (AM_HAL_UART_INT_RX_TMOUT))
{
ui32BytesRead = dev_uart1_read_buf(temp_buf);
totallen += ui32BytesRead;
// 将数据写入环形缓冲区
for (i = 0; i < ui32BytesRead; i++)
{
RingBuffer_Put(&uart1_rx, temp_buf[i]);
}
//am_util_debug_printf("uart1:%d %s\r\n",totallen, uart1_rx.RxBuffer);
//am_util_debug_printf("uart tmout:%d\n",totallen);
}
uart1_rx.ready = true;
}
}
//*****************************************************************************
//
// init uart
//
//*****************************************************************************
void dev_uart1_init(void)
{
am_hal_uart_config_t sUartConfig =
{
//
// Standard UART settings: 115200-8-N-1
//
.ui32BaudRate = 115200,
.ui32DataBits = AM_HAL_UART_DATA_BITS_8,
.ui32Parity = AM_HAL_UART_PARITY_NONE,
.ui32StopBits = AM_HAL_UART_ONE_STOP_BIT,
.ui32FlowControl = AM_HAL_UART_FLOW_CTRL_NONE,
//
// Set TX and RX FIFOs to interrupt at three-quarters full.
//
.ui32FifoLevels = (AM_HAL_UART_TX_FIFO_3_4 |
AM_HAL_UART_RX_FIFO_3_4),
//
// This code will use the standard interrupt handling for UART TX, but
// we will have a custom routine for UART RX.
//
.pui8TxBuffer = uart1_dev.TxBuffer,
.ui32TxBufferSize = MAX_UART1_SIZE,
.pui8RxBuffer = 0,
.ui32RxBufferSize = 0,
};
am_hal_uart_initialize(DEV_UART1, &g_pvUART1);
am_hal_uart_power_control(g_pvUART1, AM_HAL_SYSCTRL_WAKE, false);
am_hal_uart_configure(g_pvUART1, &sUartConfig);
//hl_dev_uart_gpio_config(g_pvUART1,config->ui32module);
am_hal_gpio_pinconfig(AM_BSP_GPIO_COM_UART1_TX, g_AM_BSP_GPIO_COM_UART1_TX);
am_hal_gpio_pinconfig(AM_BSP_GPIO_COM_UART1_RX, g_AM_BSP_GPIO_COM_UART1_RX);
//
// Make sure to enable the interrupts for RX, since the HAL doesn't already
// know we intend to use them.
//
NVIC_EnableIRQ((IRQn_Type)(UART0_IRQn + DEV_UART1));
NVIC_SetPriority(UART0_IRQn+DEV_UART1, NVIC_configMAX_SYSCALL_INTERRUPT_PRIORITY);
am_hal_uart_interrupt_enable(g_pvUART1, (AM_HAL_UART_INT_RX |
AM_HAL_UART_INT_RX_TMOUT));
dev_uart1_register(uart1_dev_receiver_handle);
am_util_debug_printf("uart1 init:\r\n");
}
//*****************************************************************************
//
//initial setup for the gps task.
//
//*****************************************************************************
void gps_task(void *pvParameters)
{
char data[1024] = {0};
uint16_t i, len;
uint16_t available;
gps_power_gpio_init();
dev_uart1_init();
am_util_debug_printf("gps init\n");
while (1)
{
if(uart1_rx.ready) //20ms,230 BITS
{
// Read data from the UART
available = RingBuffer_Available(&uart1_rx);
if(available > 0)
{
len = available > MAX_UART1_SIZE ? MAX_UART1_SIZE : available;
// 读取数据到临时缓冲区
for (i = 0; i < len; i++)
{
data[i] = RingBuffer_Get(&uart1_rx);
}
// if(gps_module_data.printf_enable)
// {
am_util_debug_printf("rec:%d,%s\r\n",len,data);
// }
if(strstr(data,"RMC")!=NULL)
{
gps_get_latitude_and_longitude(data);
//gps_connect_flag = 1;
}
memset(data,0,sizeof(data));
}
uart1_rx.ready = false;
}
else vTaskDelay(20 / portTICK_PERIOD_MS); //115200 BITS/S 20ms,230 BITS
}
}