STM32H743+ATGM332D调试记录

原创 已于 2024-07-05 09:37:55 修改 · 602 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#stm32 #嵌入式硬件 #单片机

于 2024-07-04 15:29:32 首次发布

最近在做GPS相关的功能，主控芯片使用的是STM32H7系列的，遂做个记录留念~

CUBEMX配置底层驱动

ST芯片驱动用cuber来配置还是相当方便的，这里就简单配置一下UART，因为ATGM芯片是通过串口来通讯的，就是简单的配置了一下串口：

首先配置RCC：

根据需要配置一下时钟树，这里就不多做赘述~

这里简单选个异步通讯，其他全默认即可，然后我们生成工程。

串口接收队列

为了方便解析GPS数据，我这边写了一个队列来处理这个问题：

#define MAX_SIZE 10000
typedef struct
{
    uint8_t data[MAX_SIZE];
    int front, rear;
} Queue;

void initQueue(Queue *q)
{
    q->front = 0;
    q->rear = 0;
}

int isFull(Queue *q)
{
    return (q->rear + 1) % MAX_SIZE == q->front;
}

int isEmpty(Queue *q)
{
    return q->front == q->rear;
}

int queueSize(Queue *q)
{
    return (q->rear - q->front + MAX_SIZE) % MAX_SIZE;
}

void enqueue(Queue *q, uint8_t item)
{
    if (!isFull(q))
    {
        q->data[q->rear] = item;
        q->rear = (q->rear + 1) % MAX_SIZE;
    }
    else
    {
        // todo :: if full
    }
};

uint8_t dequeue(Queue *q)
{
    uint8_t item = q->data[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    return item;
}

uint8_t getLastValidData(Queue *q)
{
    int size = queueSize(q);
    if (size == 0)
    {
        return 0;
    }
    else
    {
        return q->data[(q->rear - 1 + MAX_SIZE) % MAX_SIZE];
    }
}

uint8_t getDataAtPosition(Queue *q, int position)
{
    int size = queueSize(q);
    if (size == 0 || position >= size || position < 0)
    {
        return 0;
    }
    else
    {
        return q->data[(q->front + position) % MAX_SIZE];
    }
}

随后在回调函数中接收数据：

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1)
    {
        // SCB_InvalidateDCache_by_Addr((uint32_t *)uart_rxdata, 128);
        for (int i = 0; i < 200; i++)
        {
            enqueue(&gps2can_q, uart_rxdata[i]);
        }
        HAL_UART_Receive_DMA(&huart1, uart_rxdata, 200);
    }
}

在主循环中处理数据：

void Gps_Poll(Queue *q)
{
    uint8_t data[300] = {0};
    uint16_t size = 0;
    // judge empty
    if (isEmpty(q))
    {
        return;
    }
    // get datalength
    size = queueSize(q);
    if (size < 3)
    {
        return;
    }
    // judge front
    if (0x24 != dequeue(q))
    {
        return;
    }
    else
    {
        data[0] = 0x24;
    }
    // judge rear
    for (int i = 1; i < size; i++)
    {
        if (getDataAtPosition(q, i) == 0x0A)
        {
            for (int j = 1; j <= (i + 1); j++)
            {
                data[j] = dequeue(q);
            }

            Gps_process(data, (i + 2));

            return;
        }
    }
}

void Gps_process(uint8_t pData[], uint16_t pDataLength)
{
    uint8_t gnss = 0;
    if (pData[0] != '$')
    {
        return;
    }
    if (pData[1] == 'B' && pData[2] == 'D')
    {
        gnss = bd;
    }
    else if (pData[1] == 'G' && pData[2] == 'P')
    {
        gnss = gp;
    }
    else if (pData[1] == 'G' && pData[2] == 'L')
    {
        gnss = gl;
    }
    else if (pData[1] == 'G' && pData[2] == 'N')
    {
        gnss = gn;
    }
    else
    {
        return;
    }
    if (pData[3] == 'G' && pData[4] == 'G' && pData[5] == 'A')
    {
        switch (gnss)
        {
        case bd:
            Gps_gga(pData, pDataLength, &gps2can.atgm332d.bd.gga);
            break;
        case gp:
            break;
        case gl:
            Gps_gga(pData, pDataLength, &gps2can.atgm332d.gl.gga);
            break;
        case gn:
            break;
        default:
            break;
        }
    }
    else if (pData[3] == 'G' && pData[4] == 'L' && pData[5] == 'L')
    {
    }
    else if (pData[3] == 'G' && pData[4] == 'S' && pData[5] == 'A')
    {
    }
    else if (pData[3] == 'G' && pData[4] == 'S' && pData[5] == 'V')
    {
    }
    else if (pData[3] == 'R' && pData[4] == 'M' && pData[5] == 'C')
    {
    }
    else if (pData[3] == 'V' && pData[4] == 'T' && pData[5] == 'G')
    {
    }
    else if (pData[3] == 'Z' && pData[4] == 'D' && pData[5] == 'A')
    {
    }
}

至于为什么这样处理，感兴趣的小伙伴可以去看一下对应的NEMA协议~

我这里只给出了GGA的处理，目前我只需要用到GGA语句解析：

unsigned char AsciiToHex(uint8_t *str, uint8_t size, uint8_t *result)
{
    unsigned char temp;

    for (*result = 0; size; size--, str++)
    {
        if (('9' >= *str) && (*str >= '0'))
            temp = *str - '0';
        else if (('F' >= *str) && (*str >= 'A'))
            temp = *str - 'A' + 10;
        else if (('f' >= *str) && (*str >= 'a'))
            temp = *str - 'a' + 10;
        else
            return 1;
        *result |= temp << ((size - 1) * 4);
    }

    return 0;
}

uint8_t MMEA_CheckSum(uint8_t *buf)
{
    unsigned char i;
    unsigned char chk, result;

    for (chk = buf[1], i = 2; (buf[i] != '*') && (i < 255); i++)
    {
        chk ^= buf[i];
    }

    if (AsciiToHex(&buf[i + 1], 2, &result))
        return 3;
    if (i >= 255)
        return 2;
    if (chk != result)
        return 1;

    return 0; // 校验成功
}

void Gps_gga(uint8_t pData[], uint16_t pDataLength, nema_gga *pGGA)
{
    // next must be ,
    uint8_t index = 6;
    uint8_t count = 0;
    uint8_t hex_data = 0;
    // count ,
    for (int i = 0; i < pDataLength; i++)
    {
        if (pData[i] == ',')
        {
            count++;
        }
    }

    if (count != 14)
    {
        return;
    }

    if (MMEA_CheckSum(pData) != 0)
    {
        return;
    }

    if (pData[index] != ',')
    {
        return;
    }
    index++;
    // utc_time
    if (pData[index] == ',')
    {
        pGGA->utc_time_flag = 0;
        index++;
    }
    else
    {
        pGGA->utc_time_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->utc_time = hex_data * 10000000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->utc_time += hex_data * 1000000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->utc_time += hex_data * 100000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->utc_time += hex_data * 10000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->utc_time += hex_data * 1000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->utc_time += hex_data * 100;
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // lat
    if (pData[index] == ',')
    {
        pGGA->lat_flag = 0;
        index++;
    }
    else
    {
        pGGA->lat_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat = hex_data * 10000000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat += hex_data * 1000000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat += hex_data * 100000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat += hex_data * 10000;
        index++;
        if (pData[index] == '.')
        {
            index++;
        }
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat += hex_data * 1000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat += hex_data * 100;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat += hex_data * 10;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lat += hex_data;
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // ulat
    if (pData[index] == ',')
    {
        pGGA->ulat_flag = 0;
        index++;
    }
    else
    {
        pGGA->ulat_flag = 1;
        if (pData[index] == 'N')
        {
            pGGA->ulat = 0;
        }
        else if (pData[index] == 'S')
        {
            pGGA->ulat = 1;
        }
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // lon
    if (pData[index] == ',')
    {
        pGGA->lon_flag = 0;
        index++;
    }
    else
    {
        pGGA->lon_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon = hex_data * 100000000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data * 10000000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data * 1000000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data * 100000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data * 10000;
        index++;
        if (pData[index] == '.')
        {
            index++;
        }
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data * 1000;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data * 100;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data * 10;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->lon += hex_data;
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // ulon
    if (pData[index] == ',')
    {
        pGGA->ulon_flag = 0;
        index++;
    }
    else
    {
        pGGA->ulon_flag = 1;
        if (pData[index] == 'E')
        {
            pGGA->ulon = 0;
        }
        else if (pData[index] == 'W')
        {
            pGGA->ulon = 1;
        }
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // FS
    if (pData[index] == ',')
    {
        pGGA->fs_flag = 0;
        index++;
    }
    else
    {
        pGGA->fs_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->fs = hex_data;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // numSv
    if (pData[index] == ',')
    {
        pGGA->numsv_flag = 0;
        index++;
    }
    else
    {
        pGGA->numsv_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->numsv = hex_data * 10;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->numsv += hex_data;
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // HDOP
    if (pData[index] == ',')
    {
        pGGA->hdop_flag = 0;
        index++;
    }
    else
    {
        pGGA->hdop_flag = 1;

        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->hdop = hex_data * 100;
        index++;
        if (pData[index] == '.')
        {
            index++;
        }
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->hdop += hex_data * 10;
        index++;
        if (pData[index] == '.')
        {
            index++;
        }
        if (pData[index] != ',')
        {
            AsciiToHex(&pData[index], 1, &hex_data);
            pGGA->hdop += hex_data;
            index++;
        }
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // msl
    if (pData[index] == ',')
    {
        pGGA->msl_flag = 0;
        index++;
    }
    else
    {
        pGGA->msl_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->msl = hex_data * 100;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->msl += hex_data * 10;
        index++;
        if (pData[index] == '.')
        {
            index++;
        }
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->msl += hex_data;
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // M
    if (pData[index] == ',')
    {
        pGGA->msl_flag = 0;
        index++;
    }
    else
    {
        if (pData[index] != 'M')
        {
            pGGA->msl_flag = 0;
        }
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // sep
    if (pData[index] == ',')
    {
        pGGA->sep_flag = 0;
        index++;
    }
    else
    {
        pGGA->sep_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->sep = hex_data * 100;
        index++;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->sep += hex_data * 10;
        index++;
        if (pData[index] == '.')
        {
            index++;
        }
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->sep += hex_data;
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // M
    if (pData[index] == ',')
    {
        pGGA->sep_flag = 0;
        index++;
    }
    else
    {
        if (pData[index] != 'M')
        {
            pGGA->sep_flag = 0;
        }
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // diffage
    if (pData[index] == ',')
    {
        pGGA->diffage_flag = 0;
        index++;
    }
    else
    {
        pGGA->diffage_flag = 1;
        AsciiToHex(&pData[index], 1, &hex_data);
        pGGA->diffage = hex_data;
        index++;
        while (pData[index] != ',')
        {
            index++;
        }
        index++;
    }
    // diffsta * cs
    if (pData[index] != '*')
    {
        // pGGA->diffsta_flag = 1;
        index++;
        while (pData[index] != '*')
        {
            index++;
        }
        index++;
    }
    else
    {
        // pGGA->diffage_flag = 0;
    }
}

我这边处理上是将多个字符合并成一个大数据来处理了，可以根据需要自行选用合适的处理方案~

希望能够帮到你。

Dear_SJJ
关注
中科微GPS模块使用教程 ATGM332D ATGM336H GSP模块 单片机程序 C程序
q742971636的博客
03-18 1万+
http://www.waaax.top/forum.php?mod=viewthread&tid=35&extra=page%3D1 支持北斗/GPS/GLONASS卫星系统 支持3.3v-5v供电，可以方便接入3.3v或者5v单片机系统 板载可充电电子，可加速热启动搜星过程。 默认波特率9600，波特率可设置 TTL电平UART接口，用户连接单片机的串口TTL电平或者USB-TTL模块测试。 带有SMA和IPEX两种天线接口，方便选择自己需要的外置天线。 带有PPS授时输出引脚，方便做
基于STM32L4XX、HAL库的 ATGM332D-5N31定位模块驱动程序设计
zhusl6688的博客
03-31 500
/ 转换为km/h。// 定位状态: 0=无效, 1=GPS定位, 2=差分定位。// 地面速度(km/h)uint8_t rx_buffer[256];// 海拔高度(m)// 地面航向(度)uint8_t satellites_used;
GPS定位程序，ATGM332D模块
10-23
中科微电子GPS导航模块，原理图PCB和程序，非常好用，有说明文档，非常详细，一看就会用。
北斗GPS ATGM332D模块软硬件技术资料+STM32单片机软件工程源码.zip
05-08
北斗GPS ATGM332D模块软硬件技术资料+STM32单片机软件工程源码： 1-原理图_尺寸图 2-开发板配套例程 3-配套软件 4-官方文档 5-NMEA0183解码库源码 ATGM332D与各开发板引脚连接说明 GPS单位及纠偏.pdf ATGM332D模块用户手册 .pdf ATGM332D-5N卫星导航模块用户手册.pdf ATGM模块在线升级协议.pdf CASIC多模卫星导航接收机协议规范.pdf 中科微导航模块专用Android驱动.rar
ATGM332D 北斗定位模块.rar_ATGM332D手册_stm32 ATGM332D_北斗 GPS_北斗定位_北斗模块
07-15
GPS 北斗软件资料 使用手册 原理图 单片机例程参考 调试工具
【物联网】BDS/GNSS 全星座定位导航模块——ATGM332D-5N
Goforyouqp的博客
11-14 8403
ATGM332D-5N 系列模块是 12X16 尺寸的高性能 BDS/GNSS 全星座定位导航模块系列的总称。该系列模块产品都是基于中科微第四代低功耗 GNSS SOC单芯片—AT6558，支持多种卫星导航系统，包括中国的BDS（北斗卫星导航系统），美国的GPS，俄罗斯的GLONASS，欧盟的GALILEO，日本的QZSS以及卫星增强系统SBASWAASEGNOSGAGANMSAS。
基于STM32+OneNet设计的物联网智慧路灯(100)
06-17 7316
本次设计的智能路灯采用STM32芯片和OneNet物联网平台进行连接，开发出支持太阳能充电锂电池供电、GPS定位上传位置信息、手动/自动控制路灯开关、环境光照调节、红外传感器检测周围人员、空气质量监测等多项功能。同时，当路灯发生异常情况时，系统可以自动发送邮件或短信到指定邮箱或电话。
基于STM32+物联网设计的货车重量检测系统(OneNet)
10-24 5334
基于STM32和物联网技术设计的货车重量检测系统可以实现快速、精准地对货车载重进行检测，并且将检测结果实时上传到云平台，方便用户远程查看和数据管理。其中，OneNet是一种基于HTTP协议的物联网云平台，具有稳定、灵活、易用等优点。 系统主要由三部分组成：硬件模块、软件程序和云平台。硬件模块包括STM32单片机、称重传感器、WIFI模块等；软件程序则负责采集传感器数据，进行处理和上传；而云平台则扮演着数据存储和展示的角色。
基于STM32设计的老人摔倒报警系统OneNet_122
07-20 5504
当前设计了一种检测老人摔倒的设备，采用STM32作为主控芯片，系统包括检测摔倒模块、GPS定位模块和通信模块三部分，通过检测老年人日常状态，可以得知老年人的状态，如果监测到老年人摔倒了，此时会通过网络当前定位实时上传到OneNet物联网云端平台，家人可从手机APP上实时查看老人的位置，并且会通过蜂鸣器报警请求路人帮助，同时会发送短信通知家人。若老人在外走失迷路，可通过对应按键发送短信通知家人，家人可以在手机APP上看到老人的位置。在设备上还带有LCD显示屏，老人可以通过按键切换时间显示页面、GPS经纬度显示
基于STM32设计的老人监护系统(OneNet)_118
07-17 6913
该项目是基于STM32设计的老人监护系统。本系统可以通过脉搏心率传感器，体温传感器检测老人的脉搏状态，体温状态，把老人的数据状态在STM32单片机内部进行处理，然后通过GSM模块上传到OneNet云平台，在通过可视化界面显示出来，这样可以让子女随时随地了解到老人现在的身体情况，以便对老人的突发情况能够做出及时的预防和处理。而且如今，随着老人年纪不断的增长，身体体质不断的衰弱，在上楼梯或者走斜坡的时候很容易会发生摔倒或跌倒，如果不及时的接收到治疗，很可能会造成很严重的后果。
基于STM32F103单片机+北斗GPS_ATGM332D模块 GPS_Decode_SDCard测试实验软件例程源码.rar
11-23
基于STM32F103单片机+北斗GPS_ATGM332D模块 GPS_Decode_SDCard测试实验软件例程源码.rar
【北斗GPS_ATGM332D】模块资料.zip
07-25
北斗模块详细资料，大文件下载不易。
中科微北斗 GPS android驱动 ATGM332D ATGM336H驱动
04-19
中科微北斗 GPS android驱动 ATGM332D ATGM336H驱动 适用于Android 4、5、6系统
基于STM32的老人健康与跌倒检测系统设计
最新发布
09-10 897
型号（首选，资源丰富）或（次选，功耗极低，更适合可穿戴设备）。理由：需要多个UART（4G、GPS）、I2C（传感器、OLED）、SPI、ADC和足够的算力来运行跌倒检测算法。本项目成功设计并实现了一个功能全面、实用性强的老人健康与安全监测系统原型。系统精准地完成了多生理参数采集、高可靠性跌倒判断、精准定位和远程报警等一系列核心功能，构建了一个“端-云-APP”协同的完整解决方案。该系统对保障独居老人的生命安全、减轻子女看护压力具有显著价值。
北斗ATGM332D定位 gps驱动
锅锅的博客
10-11 2932
ATGM332D 接口 串口 协议 经纬度换算 代码示例 #include <stdio.h> int my_strcmp(char *s1, char *s2, int len) { int i; for(i = 0; i < len; i++) { if(s1[i] != s2[i]) return 0; } return 1; } char *my_strfind(char *buf, char *s, char s_
基于STM32L4XX、HAL库的ATGM332D-5N11定位模块驱动程序设计
zhusl6688的博客
06-24 196
"$PUBX,40,GLL,1,1,1,1*5D\r\n" // 启用GLL。const char *cmd = "$PUBX,40,GGA,0,0,0,0*5A\r\n" // 禁用GGA。const char *cmd = "$PUBX,40,GGA,1,1,1,1*5B\r\n" // 启用GGA。"$PUBX,40,RMC,1,1,1,1*46\r\n" // 启用RMC。
arduino驱动ATGM332D
qq_43313294的博客
05-26 1540
代码接的是硬串口3 #define GpsSerial Serial3 #define DebugSerial Serial int L = 13; //LED指示灯引脚 struct { char GPS_Buffer[80]; bool isGetData; //是否获取到GPS数据 bool isParseData; //是否解析完成 char UTCTime[11]; //UTC时间 char latitude[11];
基于stm32+atgm336h+云端
03-18
好的，用户想要实现基于STM32和ATGM336H模块与云端通信的方案，需要教程和示例代码。首先，我需要理清楚整个系统的组成部分和通信流程。 首先，ATGM336H是一个GPS模块，用于获取位置数据。STM32需要读取这个模块的...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值