【ESP32/ESP8266】GPS定位数据解析与超声测距（ATGM336H+HC-SR04）_电路方案

前言

做拓展项目需要要用GPS定位数据以及超声设计，之前没有用过ESP-12F这个开发板去做过，都是用到STM32板子，今天尝试用Arduino环境进行开发，并实现GPS经纬度数据获取以及超声测距

一、芯片介绍

这款芯片的可用io口还是比较少的，只适合做小型的设备控制，不用看图上有很多io口，其实他很多都不能用，否则就会导致启动错误，我已经踩过坑了

ESP-12F可用输出引脚列表

GPIO编号	物理引脚	特殊限制	最大输出电流	PWM支持	推荐用途
GPIO4	Pin 10	无	12mA	✔️	LED控制、传感器驱动
GPIO5	Pin 11	启动时需高电平	12mA	✔️	继电器、数字输出
GPIO12	Pin 14	启动时需低电平	12mA	✔️	按键输入、低功耗设备
GPIO13	Pin 15	无	12mA	✔️	SPI MOSI、数据总线
GPIO14	Pin 16	启动时需高电平	12mA	✔️	SPI CLK、高速信号
GPIO15	Pin 17	必须启动时低电平	12mA	✔️	接地设备控制

禁止使用的输出引脚

GPIO编号	限制原因
GPIO0	启动模式选择（需外部上拉）
GPIO2	内部上拉，启动时需高电平
GPIO16	仅支持开漏输出

二、材料准备

准备这是四个材料就行了

ESP8266开发板

ESP8266-Node

显示屏-0.96寸

GPS模块

ATGM336H

GPS是每一秒自动进行发送数据，当GPS状态的闪烁，就说明获取到了卫星定位了

超声波模块

HC-SR04

三、代码编写

这个的话，我主要调一个重要部分，最后会附上源码，因为我代码里面带了联网部分，我这边就先暂时把联网部分屏蔽掉的

1 超声测距部分

一个io设置为输入，一个设置为输出

// 检测距离
void Distance_text(void) {

  // 发送触发信号
  digitalWrite(trigPin, LOW);   // 确保先拉低Trig引脚
  delayMicroseconds(2);         // 维持2微秒
  digitalWrite(trigPin, HIGH);  // 触发脉冲
  delayMicroseconds(10);        // 维持10微秒
  digitalWrite(trigPin, LOW);   // 结束触发
  // 测量回波脉冲持续时间
  distance = float(pulseIn(echoPin, HIGH) * 17) / 1000;
  if ((int)distance < 50) {

  } else {

  }
  // 显示结果
  // Serial.print("disc:");
  // if (distance > 0) {
  //   Serial.print(distance);
  //   Serial.println(" cm");
  // } else {
  //   Serial.println("out");
  // }
}

2 GPS部分

使用模拟串口，进行数据接收和解析。并且这里利用了显示了时区，我们的时区需要+8H，就是当前时间，程序已经完成这部分

void gpsParser() {
  while (gpsSerial.available()) {
    char Res = gpsSerial.read();

    if (Res == '$') {
      point1 = 0;
      memset(USART_RX2_BUF, 0, sizeof(USART_RX2_BUF));
    }

    USART_RX2_BUF[point1++] = Res;

    // 检测GPRMC/GNRMC语句
    if (point1 >= 6 && USART_RX2_BUF[3] == 'R' && USART_RX2_BUF[4] == 'M' && USART_RX2_BUF[5] == 'C') {

      if (Res == 'n') {
        memset(Save_Data.GPS_Buffer, 0, sizeof(Save_Data.GPS_Buffer));
        memcpy(Save_Data.GPS_Buffer, USART_RX2_BUF, point1);
        Save_Data.isGetData = true;
        point1 = 0;
      }
    }

    if (point1 >= sizeof(USART_RX2_BUF) - 1) {
      point1 = 0;
    }
  }
}

void parseGpsBuffer() {
  char* subString;
  char* subStringNext;
  char usefullBuffer[2] = { 0 };
  int commaCount = 0;

  subString = strtok(Save_Data.GPS_Buffer, ",");
  while (subString != NULL) {
    switch (commaCount) {
      case 1:  // UTC时间
        strncpy(Save_Data.UTCTime, subString, sizeof(Save_Data.UTCTime));
        break;
      case 2:  // 数据有效性
        strncpy(usefullBuffer, subString, sizeof(usefullBuffer));
        break;
      case 3:  // 纬度
        strncpy(Save_Data.latitude, subString, sizeof(Save_Data.latitude));
        break;
      case 4:  // N/S
        strncpy(Save_Data.N_S, subString, sizeof(Save_Data.N_S));
        break;
      case 5:  // 经度
        strncpy(Save_Data.longitude, subString, sizeof(Save_Data.longitude));
        break;
      case 6:  // E/W
        strncpy(Save_Data.E_W, subString, sizeof(Save_Data.E_W));
        break;
    }
    subString = strtok(NULL, ",");
    commaCount++;
  }

  Save_Data.isUsefull = (usefullBuffer[0] == 'A');
  Save_Data.isParseData = true;
}

void printGpsBuffer() {
  if (Save_Data.isUsefull) {
    // 转换经度
    longitude_sum = atof(Save_Data.longitude);
    int longitude_int = (int)(longitude_sum / 100);
    float longitude = longitude_int + (longitude_sum - longitude_int * 100) / 60;

    // 转换纬度
    latitude_sum = atof(Save_Data.latitude);
    int latitude_int = (int)(latitude_sum / 100);
    float latitude = latitude_int + (latitude_sum - latitude_int * 100) / 60;
    // 转化为经纬度
    longitude_sum = longitude_int + ((longitude_sum / 100 - longitude_int) * 100) / 60;
    latitude_sum = latitude_int + ((latitude_sum / 100 - latitude_int) * 100) / 60;


    // 时间解析修正
    String utcTime = Save_Data.UTCTime;
    if (utcTime.length() >= 6) {
      // 安全解析
      hour = utcTime.substring(0, 2).toInt();    // 小时
      minute = utcTime.substring(2, 4).toInt();  // 分钟
      second = utcTime.substring(4, 6).toInt();  // 秒
      // 时区调整（UTC+8）
      hour += 8;
      // 处理溢出
      if (hour >= 24) {
        hour -= 24;
        // 日期+1（需补充日期处理逻辑）
      } else if (hour < 0) {
        hour += 24;
        // 日期-1
      }

      // 时间有效性验证
      if (hour < 0 || hour >= 24 || minute < 0 || minute >= 60 || second < 0 || second >= 60) {
        Serial.println("Invalid Time Data");
        return;
      }

      格式化输出
      Serial.printf("Local Time: %02d:%02d:%02dn", hour, minute, second);
    } else {
      Serial.println("UTC Time Format Error");
    }

    Serial.print("Latitude: ");
    Serial.print(latitude, 6);
    Serial.print(" ");
    Serial.println(Save_Data.N_S);

    Serial.print("Longitude: ");
    Serial.print(longitude, 6);
    Serial.print(" ");
    Serial.println(Save_Data.E_W);
    Serial.println("---------------------");
  } else {
    Serial.println("GPS Data Invalid");
  }
}

3 完整代码

编译芯片的选择：ESPino（ESP-12）Module

#include <SoftwareSerial.h>
#include <PubSubClient.h>
#include <Ticker.h>
#include <ESP8266WiFi.h>
//OLED
#include <U8g2lib.h>
#include <Wire.h>
//JSON
#include <ArduinoJson.h>

// 设置wifi接入信息(请根据您的WiFi信息进行修改)
const char* ssid = "NET";
const char* password = "12345678";
const char* mqttServer = "iot-06z00axdhgfk24n.mqtt.iothub.aliyuncs.com";
// 如以上MQTT服务器无法正常连接，请前往以下页面寻找解决方案
// http://www.taichi-maker.com/public-mqtt-broker/

Ticker ticker;
WiFiClient wifiClient;
PubSubClient mqttClient(wifiClient);
int count;  // Ticker计数用变量
int count_2;
// ****************************************************
// 注意！以下需要用户根据然也物联平台信息进行修改！否则无法工作!
// ****************************************************
const char* mqttUserName = "smartdevice&h9sjy2rtcTI";                                                          // 服务端连接用户名(需要修改)
const char* mqttPassword = "5ba9463de09043190a8a743647518c46b1db6e1bfc2e0021198efe3384580772";                 // 服务端连接密码(需要修改)
const char* clientId = "h9sjy2rtcTI.smartdevice|securemode=2,signmethod=hmacsha256,timestamp=1739158837609|";  // 客户端id (需要修改)
const char* subTopic = "/broadcast/h9sjy2rtcTI/test1";                                                         // 订阅主题(需要修改)
const char* pubTopic = "/broadcast/h9sjy2rtcTI/test2";                                                         // 订阅主题(需要修改)
const char* willTopic = "/broadcast/h9sjy2rtcTI/test2";                                                        // 遗嘱主题名称(需要修改)
// ****************************************************

//遗嘱相关信息
const char* willMsg = "esp8266 offline";  // 遗嘱主题信息
const int willQos = 0;                    // 遗嘱QoS
const int willRetain = false;             // 遗嘱保留

const int subQoS = 1;            // 客户端订阅主题时使用的QoS级别（截止2020-10-07，仅支持QoS = 1，不支持QoS = 2）
const bool cleanSession = true;  // 清除会话（如QoS>0必须要设为false）


// LED 配置
#define LED_BUILTIN 15
#define LED 2
bool ledStatus = HIGH;
int Waning = 0;
int Ledstate = 0;
// OLED
#define SCL 14
#define SDA 12
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, /*reset=*/U8X8_PIN_NONE);
char str[50];  //拼接字符使用
// 定义超声波传感器引脚
#define trigPin 5
#define echoPin 4
float distance;

// 配置软串口（根据实际接线修改引脚）
SoftwareSerial gpsSerial(15, 13);  // RX: D8, TX: D7
// GPS数据结构
struct {
  char GPS_Buffer[128];
  char UTCTime[12];
  char latitude[16];
  char N_S[2];
  char longitude[16];
  char E_W[2];
  bool isGetData = false;
  bool isParseData = false;
  bool isUsefull = false;
} Save_Data;
// 全局变量
char USART_RX2_BUF[256];
unsigned char point1 = 0;
float longitude_sum, latitude_sum;
int hour, minute, second;

void setup() {

  Serial.begin(9600);     // 启动串口通讯
  gpsSerial.begin(9600);  // GPS模块常用波特率
  gpsSerial.println("GPS Parser Started");
  //OELD
  u8g2.begin();
  u8g2.setFont(u8g2_font_t0_16_tf);  //设定字体  u8g2_font_ncenB08_tr

  // //设置ESP8266工作模式为无线终端模式
  // WiFi.mode(WIFI_STA);
  // // 连接WiFi
  // connectWifi();
  // // 设置MQTT服务器和端口号
  // mqttClient.setServer(mqttServer, 1883);
  // mqttClient.setCallback(receiveCallback);
  // // 连接MQTT服务器
  // connectMQTTserver();

  // Ticker定时对象
  ticker.attach(1, tickerCount);
  // LED和蜂鸣器
  pinMode(LED_BUILTIN, OUTPUT);          // 设置板上LED引脚为输出模式
  pinMode(LED, OUTPUT);                 // 设置板上LED引脚为输出模式
  digitalWrite(LED, ledStatus);  // 启动后关闭板上LED
  digitalWrite(LED_BUILTIN, ledStatus);  // 启动后关闭板上LED

  pinMode(trigPin, OUTPUT);  // 设置Trig引脚为输出模式
  pinMode(echoPin, INPUT);   // 设置Echo引脚为输入模式

}
void loop() {
  // // 如果开发板未能成功连接服务器，则尝试连接服务器
  // if (!mqttClient.connected()) {
  //   connectMQTTserver();
  // } else {
    //1秒更新一次
    if (count_2 >= 1) {

      Distance_text();  // 测量距离
      u8g2.clearBuffer();
      // 解析 GPS
      if (Save_Data.isGetData) {
        parseGpsBuffer();
        Save_Data.isGetData = false;
      }
      if (Save_Data.isParseData) {
        printGpsBuffer();
        Save_Data.isParseData = false;
      }
      // LED
      if (Ledstate) {
        digitalWrite(LED_BUILTIN, HIGH);  // 启动
      } else {
        digitalWrite(LED_BUILTIN, LOW);
        gpsSerial.println("欢迎使用");
        Serial.print("欢迎使用");  
      }
      if (ledStatus == LOW) {
        ledStatus = HIGH;
        digitalWrite(LED, ledStatus);

      } else {
        ledStatus = LOW;
        digitalWrite(LED, ledStatus);
      }
      if ((int)longitude_sum > 1) {
        sprintf(str, "Log: %.6f", longitude_sum);
        u8g2.drawStr(0, 16, str);
        sprintf(str, "Lat: %.6f", latitude_sum);
        u8g2.drawStr(0, 32, str);
        sprintf(str, "Time: %02d:%02d:%02d", hour, minute, second);
        u8g2.drawStr(0, 48, str);
      } else {
        sprintf(str, "Log: error", longitude_sum);
        u8g2.drawStr(0, 16, str);
        sprintf(str, "Lat: error", latitude_sum);
        u8g2.drawStr(0, 32, str);
        sprintf(str, "Time:error", hour, minute, second);
        u8g2.drawStr(0, 48, str);
      }

      sprintf(str, "Disc: %.2f CM", distance);
      u8g2.drawStr(0, 64, str);
      u8g2.sendBuffer();  //显示

      count_2 = 0;
    }
    //4秒发送一次
    if (count >= 4) {
      // 每隔4秒钟发布一次信息
      // pubMQTTmsg();
      count = 0;
    }
  }

  gpsParser();
  // 处理信息以及心跳
  mqttClient.loop();
}
// 连接WiFi
void connectWiFi() {
  WiFi.begin(ssid, password);
  //Serial.print("Connecting");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    
  }
 // Serial.println("nConnected! IP: " + WiFi.localIP().toString());
}
//计时器
void tickerCount() {
  count++;
  count_2++;
}
// 连接MQTT服务器并订阅信息
void connectMQTTserver() {
  // 根据ESP8266的MAC地址生成客户端ID（避免与其它ESP8266的客户端ID重名）
  /* 连接MQTT服务器
  boolean connect(const char* id, const char* user, 
                  const char* pass, const char* willTopic, 
                  uint8_t willQos, boolean willRetain, 
                  const char* willMessage, boolean cleanSession); 
  若让设备在离线时仍然能够让qos1工作，则connect时的cleanSession需要设置为false                
                  */
  if (mqttClient.connect(clientId, mqttUserName,
                         mqttPassword, willTopic,
                         willQos, willRetain, willMsg, cleanSession)) {
    // Serial.print("MQTT Server Connected. ClientId: ");
    // Serial.println(clientId);
    // Serial.print("MQTT Server: ");
    // Serial.println(mqttServer);

    subscribeTopic();  // 订阅指定主题

  } else {
    // Serial.print("MQTT Server Connect Failed. Client State:");
    // Serial.println(mqttClient.state());
    delay(5000);
  }
}

// 收到信息后的回调函数
void receiveCallback(char* topic, byte* payload, unsigned int length) {
  // Serial.print("Message Received [");
  // Serial.print(topic);
  // Serial.print("] ");
  // for (int i = 0; i < length; i++) {
  //   Serial.print((char)payload[i]);
  // }
  //解析数据
  massage_parse_json((char*)payload);
  //回传数据
  // pubMQTTmsg();
}

// 订阅指定主题
void subscribeTopic() {
  // 通过串口监视器输出是否成功订阅主题以及订阅的主题名称
  // 请注意subscribe函数第二个参数数字为QoS级别。这里为QoS = 1
  if (mqttClient.subscribe(subTopic, subQoS)) {
    //Serial.println(subTopic);
  } else {
    //Serial.print("Subscribe Fail...");
    connectMQTTserver();  // 则尝试连接服务器
  }
}

// 发布信息
void pubMQTTmsg() {
  char pubMessage[254];
  // 数据流
  MQTT_FillBuf(pubMessage);

  // 实现ESP8266向主题发布信息
  if (mqttClient.publish(pubTopic, pubMessage)) {
    //Serial.println("Publish Topic:");Serial.println(pubTopic);
    //Serial.println("Publish message:");
    //Serial.println(pubMessage);
  } else {
    subscribeTopic();  // 则尝试连接服务器
    //Serial.println("Message Publish Failed.");
  }
}

// ESP8266连接wifi
void connectWifi() {

  u8g2.clearDisplay();  // 清屏
  sprintf(str, "Wait ...  ");
  u8g2.drawStr(0, 32, str);
  u8g2.sendBuffer();  //显示
  WiFi.begin(ssid, password);

  //等待WiFi连接,成功连接后输出成功信息
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    // Serial.print(".");
  }

  //Serial.println("WiFi Connected!");
}

// 数据封装
unsigned char MQTT_FillBuf(char* buf) {

  char text[256];
  memset(text, 0, sizeof(text));

  strcpy(buf, "{");
  if ((int)latitude_sum > 1) {
    memset(text, 0, sizeof(text));
    sprintf(text, ""lat":"%.6f",", latitude_sum);  // Temp是数据流的一个名称，temper是温度值
    strcat(buf, text);
    memset(text, 0, sizeof(text));
    sprintf(text, ""log":"%.6f",", longitude_sum);  // Temp是数据流的一个名称，temper是温度值
    strcat(buf, text);
  }


  memset(text, 0, sizeof(text));
  sprintf(text, ""disc":"%d",", (int)distance);  // Temp是数据流的一个名称，temper是温度值
  strcat(buf, text);

  memset(text, 0, sizeof(text));
  sprintf(text, ""waring":"%d",", Waning);  // Temp是数据流的一个名称，temper是温度值
  strcat(buf, text);

  memset(text, 0, sizeof(text));
  sprintf(text, ""led":"%d"", digitalRead(LED_BUILTIN));  // Temp是数据流的一个名称，temper是温度值
  strcat(buf, text);

  memset(text, 0, sizeof(text));
  sprintf(text, "}");
  strcat(buf, text);

  return strlen(buf);
}

// 解析json数据
void massage_parse_json(char* message) {
  // 声明一个 JSON 文档对象
  StaticJsonDocument<200> doc;
  // 解析 JSON 数据
  DeserializationError error = deserializeJson(doc, (const char*)message);
  // 检查解析是否成功
  if (error) {
    // Serial.print("Failed to parse JSON: ");
    // Serial.println(error.c_str());
    return;
  }
  // 从解析后的 JSON 文档中获取键值对
  int cmd = doc["cmd"];
  JsonObject data = doc["data"];
  switch (cmd) {
    case 1:
      Ledstate = data["led"];
      count = 1;
      break;
    case 2:
      if((int)latitude_sum > 1){
        sprintf(str, "当前时间:%02d:%02d:%02d", hour, minute, second);
        gpsSerial.println(str);
      }else{
        sprintf(str, "请先到开阔地带进行定位定位", hour, minute, second);
        gpsSerial.println(str);
      }
      count = 1;
      break;
    case 3:

      count = 1;
      break;
  }
}
// 检测距离
void Distance_text(void) {

  // 发送触发信号
  digitalWrite(trigPin, LOW);   // 确保先拉低Trig引脚
  delayMicroseconds(2);         // 维持2微秒
  digitalWrite(trigPin, HIGH);  // 触发脉冲
  delayMicroseconds(10);        // 维持10微秒
  digitalWrite(trigPin, LOW);   // 结束触发
  // 测量回波脉冲持续时间
  distance = float(pulseIn(echoPin, HIGH) * 17) / 1000;
  if ((int)distance < 50) {

  } else {

  }
  // 显示结果
  // Serial.print("disc:");
  // if (distance > 0) {
  //   Serial.print(distance);
  //   Serial.println(" cm");
  // } else {
  //   Serial.println("out");
  // }
}

void gpsParser() {
  while (gpsSerial.available()) {
    char Res = gpsSerial.read();

    if (Res == '$') {
      point1 = 0;
      memset(USART_RX2_BUF, 0, sizeof(USART_RX2_BUF));
    }

    USART_RX2_BUF[point1++] = Res;

    // 检测GPRMC/GNRMC语句
    if (point1 >= 6 && USART_RX2_BUF[3] == 'R' && USART_RX2_BUF[4] == 'M' && USART_RX2_BUF[5] == 'C') {

      if (Res == 'n') {
        memset(Save_Data.GPS_Buffer, 0, sizeof(Save_Data.GPS_Buffer));
        memcpy(Save_Data.GPS_Buffer, USART_RX2_BUF, point1);
        Save_Data.isGetData = true;
        point1 = 0;
      }
    }

    if (point1 >= sizeof(USART_RX2_BUF) - 1) {
      point1 = 0;
    }
  }
}

void parseGpsBuffer() {
  char* subString;
  char* subStringNext;
  char usefullBuffer[2] = { 0 };
  int commaCount = 0;

  subString = strtok(Save_Data.GPS_Buffer, ",");
  while (subString != NULL) {
    switch (commaCount) {
      case 1:  // UTC时间
        strncpy(Save_Data.UTCTime, subString, sizeof(Save_Data.UTCTime));
        break;
      case 2:  // 数据有效性
        strncpy(usefullBuffer, subString, sizeof(usefullBuffer));
        break;
      case 3:  // 纬度
        strncpy(Save_Data.latitude, subString, sizeof(Save_Data.latitude));
        break;
      case 4:  // N/S
        strncpy(Save_Data.N_S, subString, sizeof(Save_Data.N_S));
        break;
      case 5:  // 经度
        strncpy(Save_Data.longitude, subString, sizeof(Save_Data.longitude));
        break;
      case 6:  // E/W
        strncpy(Save_Data.E_W, subString, sizeof(Save_Data.E_W));
        break;
    }
    subString = strtok(NULL, ",");
    commaCount++;
  }

  Save_Data.isUsefull = (usefullBuffer[0] == 'A');
  Save_Data.isParseData = true;
}

void printGpsBuffer() {
  if (Save_Data.isUsefull) {
    // 转换经度
    longitude_sum = atof(Save_Data.longitude);
    int longitude_int = (int)(longitude_sum / 100);
    float longitude = longitude_int + (longitude_sum - longitude_int * 100) / 60;

    // 转换纬度
    latitude_sum = atof(Save_Data.latitude);
    int latitude_int = (int)(latitude_sum / 100);
    float latitude = latitude_int + (latitude_sum - latitude_int * 100) / 60;
    // 转化为经纬度
    longitude_sum = longitude_int + ((longitude_sum / 100 - longitude_int) * 100) / 60;
    latitude_sum = latitude_int + ((latitude_sum / 100 - latitude_int) * 100) / 60;


    // 时间解析修正
    String utcTime = Save_Data.UTCTime;
    if (utcTime.length() >= 6) {
      // 安全解析
      hour = utcTime.substring(0, 2).toInt();    // 小时
      minute = utcTime.substring(2, 4).toInt();  // 分钟
      second = utcTime.substring(4, 6).toInt();  // 秒
      // 时区调整（UTC+8）
      hour += 8;
      // 处理溢出
      if (hour >= 24) {
        hour -= 24;
        // 日期+1（需补充日期处理逻辑）
      } else if (hour < 0) {
        hour += 24;
        // 日期-1
      }

      // 时间有效性验证
      if (hour < 0 || hour >= 24 || minute < 0 || minute >= 60 || second < 0 || second >= 60) {
        Serial.println("Invalid Time Data");
        return;
      }

      格式化输出
      Serial.printf("Local Time: %02d:%02d:%02dn", hour, minute, second);
    } else {
      Serial.println("UTC Time Format Error");
    }

    Serial.print("Latitude: ");
    Serial.print(latitude, 6);
    Serial.print(" ");
    Serial.println(Save_Data.N_S);

    Serial.print("Longitude: ");
    Serial.print(longitude, 6);
    Serial.print(" ");
    Serial.println(Save_Data.E_W);
    Serial.println("---------------------");
  } else {
    Serial.println("GPS Data Invalid");
  }
}