VK2828U7G5LF GPS Module

#include <Arduino.h>

// ------------------------------------------------------------
// VK2828U7G5LF <-> ESP32 pin assignment
// ------------------------------------------------------------

static constexpr int GPS_TX_PIN  = 34; // GPS TX -> ESP32 RX
static constexpr int GPS_RX_PIN  = 27; // ESP32 TX -> GPS
static constexpr int GPS_PPS_PIN = 35; // GPS PPS -> ESP32 input
static constexpr int GPS_EN_PIN  = 32; // ESP32 -> GPS EN

static constexpr uint32_t GPS_BAUD = 9600;

HardwareSerial GPS(2);

// UBX-MON-VER poll
static const uint8_t MON_VER[] = {
    0xB5, 0x62,
    0x0A, 0x04,
    0x00, 0x00,
    0x0E, 0x34
};

// ------------------------------------------------------------
// UBX checksum
// ------------------------------------------------------------

void ubxChecksum(const uint8_t *data,
                 size_t length,
                 uint8_t &ckA,
                 uint8_t &ckB)
{
    ckA = 0;
    ckB = 0;

    for (size_t i = 0; i < length; ++i)
    {
        ckA += data[i];
        ckB += ckA;
    }
}

// ------------------------------------------------------------

void printHex(const uint8_t *data, size_t length)
{
    for (size_t i = 0; i < length; ++i)
    {
        if (data[i] < 0x10)
            Serial.print('0');

        Serial.print(data[i], HEX);
        Serial.print(' ');
    }

    Serial.println();
}

// ------------------------------------------------------------
// MON-VER payload consists of:
// 30 bytes: software version
// 10 bytes: hardware version
// remaining: 30-byte extension strings
// ------------------------------------------------------------

void printFixedString(const uint8_t *data, size_t length)
{
    for (size_t i = 0; i < length; ++i)
    {
        if (data[i] == 0)
            break;

        char c = static_cast<char>(data[i]);

        if (c >= 32 && c <= 126)
            Serial.print(c);
        else
            Serial.print('.');
    }
}

// ------------------------------------------------------------

void decodeMonVer(const uint8_t *packet, size_t packetLength)
{
    if (packetLength < 8)
    {
        Serial.println("MON-VER packet too short.");
        return;
    }

    const uint16_t payloadLength =
        packet[4] |
        (static_cast<uint16_t>(packet[5]) << 8);

    const size_t expectedLength =
        8 + payloadLength;

    if (packetLength != expectedLength)
    {
        Serial.printf(
            "MON-VER length mismatch: packet=%u expected=%u\n",
            static_cast<unsigned>(packetLength),
            static_cast<unsigned>(expectedLength));
        return;
    }

    uint8_t ckA;
    uint8_t ckB;

    // Checksum covers CLASS through PAYLOAD.
    ubxChecksum(
        &packet[2],
        4 + payloadLength,
        ckA,
        ckB);

    const uint8_t receivedA = packet[6 + payloadLength];
    const uint8_t receivedB = packet[7 + payloadLength];

    Serial.printf(
        "Checksum: calculated %02X %02X, received %02X %02X -> %s\n",
        ckA,
        ckB,
        receivedA,
        receivedB,
        (ckA == receivedA && ckB == receivedB)
            ? "VALID"
            : "INVALID");

    if (ckA != receivedA || ckB != receivedB)
        return;

    const uint8_t *payload = &packet[6];

    Serial.println();
    Serial.println("========== UBX-MON-VER ==========");

    if (payloadLength >= 40)
    {
        Serial.print("Software Version : ");
        printFixedString(payload, 30);
        Serial.println();

        Serial.print("Hardware Version : ");
        printFixedString(payload + 30, 10);
        Serial.println();
    }

    Serial.println("Extensions:");

    for (size_t offset = 40;
         offset + 30 <= payloadLength;
         offset += 30)
    {
        Serial.print("  ");
        printFixedString(payload + offset, 30);
        Serial.println();
    }

    Serial.println("=================================");
    Serial.println();
}

// ------------------------------------------------------------
// Receive one complete UBX packet.
// ------------------------------------------------------------

bool receiveUBXPacket(uint8_t *buffer,
                      size_t bufferSize,
                      size_t &packetLength,
                      uint32_t timeoutMs)
{
    packetLength = 0;
    const uint32_t start = millis();

    int state = 0;
    uint16_t payloadLength = 0;

    while (millis() - start < timeoutMs)
    {
        while (GPS.available())
        {
            const uint8_t b = GPS.read();

            if (state == 0)
            {
                if (b == 0xB5)
                {
                    buffer[0] = b;
                    packetLength = 1;
                    state = 1;
                }

                continue;
            }

            if (state == 1)
            {
                if (b == 0x62)
                {
                    buffer[1] = b;
                    packetLength = 2;
                    state = 2;
                }
                else
                {
                    state = 0;
                    packetLength = 0;
                }

                continue;
            }

            if (state == 2)
            {
                if (packetLength >= bufferSize)
                    return false;

                buffer[packetLength++] = b;

                if (packetLength == 6)
                {
                    payloadLength =
                        buffer[4] |
                        (static_cast<uint16_t>(buffer[5]) << 8);

                    const size_t totalLength =
                        8 + payloadLength;

                    if (totalLength > bufferSize)
                    {
                        Serial.printf(
                            "UBX packet too large: %u bytes\n",
                            static_cast<unsigned>(totalLength));
                        return false;
                    }
                }

                if (packetLength >= 8)
                {
                    const size_t expectedLength =
                        8 + payloadLength;

                    if (packetLength == expectedLength)
                        return true;
                }
            }
        }

        delay(1);
    }

    return false;
}

// ------------------------------------------------------------

void sendMonVer()
{
    Serial.println("Sending UBX-MON-VER poll...");
    GPS.write(MON_VER, sizeof(MON_VER));
    GPS.flush();
}

// ------------------------------------------------------------

void setup()
{
    Serial.begin(115200);
    delay(500);

    Serial.println();
    Serial.println("========================================");
    Serial.println(" VK2828U7G5LF / u-blox identification");
    Serial.println("========================================");

    pinMode(GPS_PPS_PIN, INPUT);

    pinMode(GPS_EN_PIN, OUTPUT);
    digitalWrite(GPS_EN_PIN, HIGH);

    delay(500);

    GPS.begin(
        GPS_BAUD,
        SERIAL_8N1,
        GPS_TX_PIN,
        GPS_RX_PIN);

    Serial.println("GPS UART started at 9600 8N1.");
    Serial.println("UART RX = GPIO34");
    Serial.println("UART TX = GPIO27");
    Serial.println("PPS     = GPIO35");
    Serial.println("EN      = GPIO32");
    Serial.println();

    delay(1000);

    while (GPS.available())
        GPS.read();

    sendMonVer();

    uint8_t packet[1024];
    size_t packetLength;

    if (receiveUBXPacket(
            packet,
            sizeof(packet),
            packetLength,
            3000))
    {
        Serial.println();
        Serial.println("Received UBX packet:");
        printHex(packet, packetLength);

        const uint8_t cls = packet[2];
        const uint8_t id  = packet[3];

        if (cls == 0x0A && id == 0x04)
        {
            decodeMonVer(packet, packetLength);
        }
        else
        {
            Serial.printf(
                "Received UBX class %02X ID %02X\n",
                cls,
                id);
        }
    }
    else
    {
        Serial.println(
            "No complete UBX packet received within timeout.");
    }

    Serial.println();
    Serial.println("Continuing to monitor GPS output...");
}

// ------------------------------------------------------------

void loop()
{
    static uint32_t lastPoll = 0;

    while (GPS.available())
    {
        uint8_t b = GPS.read();

        if (b >= 32 && b <= 126)
            Serial.write(b);
        else if (b == '\r' || b == '\n')
            Serial.write(b);
        else
            Serial.printf("[%02X]", b);
    }

    if (millis() - lastPoll >= 10000)
    {
        lastPoll = millis();

        Serial.println();
        Serial.println();
        Serial.println("--- MON-VER diagnostic poll ---");

        sendMonVer();

        uint8_t packet[1024];
        size_t packetLength;

        if (receiveUBXPacket(
                packet,
                sizeof(packet),
                packetLength,
                3000))
        {
            Serial.print("UBX packet: ");
            printHex(packet, packetLength);

            if (packet[2] == 0x0A &&
                packet[3] == 0x04)
            {
                decodeMonVer(packet, packetLength);
            }
        }
        else
        {
            Serial.println("No UBX response.");
        }
    }

    delay(1);
}