adafruit-mirror/Adafruit_uBlox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clang

Browse source
This commit is contained in:
brentru 2025-07-21 10:52:34 -04:00
parent 8f6b59b218
commit 5eb550766a
6 changed files with 477 additions and 430 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

382
Adafruit_UBX.cpp
View file

@ -5,8 +5,9 @@
* *
* @section intro_sec Introduction * @section intro_sec Introduction
* *
* This is a library for parsing UBX protocol messages from u-blox GPS/RTK modules. * This is a library for parsing UBX protocol messages from u-blox GPS/RTK
* It works with any Stream-based interface including UART and DDC (I2C). * modules. It works with any Stream-based interface including UART and DDC
* (I2C).
* *
* Designed specifically to work with u-blox GPS/RTK modules * Designed specifically to work with u-blox GPS/RTK modules
* like NEO-M8P, ZED-F9P, etc. * like NEO-M8P, ZED-F9P, etc.
@ -22,11 +23,10 @@
#include "Adafruit_UBX.h" #include "Adafruit_UBX.h"
/*! /*!
* @brief Constructor * @brief Constructor
* @param stream Reference to a Stream object (Serial, Adafruit_UBloxDDC, etc.) * @param stream Reference to a Stream object (Serial, Adafruit_UBloxDDC,
* etc.)
*/ */
Adafruit_UBX::Adafruit_UBX(Stream &stream) { Adafruit_UBX::Adafruit_UBX(Stream &stream) {
_stream = &stream; _stream = &stream;
@ -42,9 +42,6 @@ bool Adafruit_UBX::begin() {
return true; return true;
} }
/*! /*!
* @brief Configure the GPS module to output only UBX protocol (disables NMEA) * @brief Configure the GPS module to output only UBX protocol (disables NMEA)
* @param portID Port identifier (UBX_PORT_DDC, UBX_PORT_UART1, etc.) * @param portID Port identifier (UBX_PORT_DDC, UBX_PORT_UART1, etc.)
@ -52,7 +49,8 @@ bool Adafruit_UBX::begin() {
* @param timeout_ms Maximum time to wait for acknowledgment in milliseconds * @param timeout_ms Maximum time to wait for acknowledgment in milliseconds
* @return UBXSendStatus indicating success, failure, or timeout * @return UBXSendStatus indicating success, failure, or timeout
*/ */
UBXSendStatus Adafruit_UBX::setUBXOnly(UBXPortId portID, bool checkAck, uint16_t timeout_ms) { UBXSendStatus Adafruit_UBX::setUBXOnly(UBXPortId portID, bool checkAck,
uint16_t timeout_ms) {
UBX_CFG_PRT_t cfgPrt; UBX_CFG_PRT_t cfgPrt;
// Zero out the structure // Zero out the structure
@ -63,47 +61,48 @@ UBXSendStatus Adafruit_UBX::setUBXOnly(UBXPortId portID, bool checkAck, uint16_t
// Configure the port appropriately // Configure the port appropriately
switch (portID) { switch (portID) {
case UBX_PORT_DDC: // I2C/DDC port case UBX_PORT_DDC: // I2C/DDC port
// Set the I2C address to 0x42 (the default) // Set the I2C address to 0x42 (the default)
// For DDC, the mode field contains the I2C address in bits 7:1 // For DDC, the mode field contains the I2C address in bits 7:1
cfgPrt.fields.mode = 0x42 << 1; // 0x84 cfgPrt.fields.mode = 0x42 << 1; // 0x84
// Set protocol masks to UBX only // Set protocol masks to UBX only
cfgPrt.fields.inProtoMask = UBX_PROTOCOL_UBX; cfgPrt.fields.inProtoMask = UBX_PROTOCOL_UBX;
cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX; cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX;
break; break;
case UBX_PORT_UART1: // Fall through case UBX_PORT_UART1: // Fall through
case UBX_PORT_UART2: // UART ports case UBX_PORT_UART2: // UART ports
// Keep current baud rate (baudRate = 0 keeps current setting) // Keep current baud rate (baudRate = 0 keeps current setting)
// Set 8N1 mode for binary protocol // Set 8N1 mode for binary protocol
cfgPrt.fields.mode = UBX_UART_MODE_8N1; cfgPrt.fields.mode = UBX_UART_MODE_8N1;
// Set protocol masks to UBX only // Set protocol masks to UBX only
cfgPrt.fields.inProtoMask = UBX_PROTOCOL_UBX; cfgPrt.fields.inProtoMask = UBX_PROTOCOL_UBX;
cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX; cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX;
break; break;
case UBX_PORT_USB: // USB port case UBX_PORT_USB: // USB port
// Set protocol masks to UBX only // Set protocol masks to UBX only
cfgPrt.fields.inProtoMask = UBX_PROTOCOL_UBX; cfgPrt.fields.inProtoMask = UBX_PROTOCOL_UBX;
cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX; cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX;
break; break;
case UBX_PORT_SPI: // SPI port case UBX_PORT_SPI: // SPI port
// Set protocol masks to UBX only // Set protocol masks to UBX only
cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX; cfgPrt.fields.outProtoMask = UBX_PROTOCOL_UBX;
break; break;
default: default:
if (verbose_debug > 0) { if (verbose_debug > 0) {
Serial.println(F("UBX: Invalid port ID")); Serial.println(F("UBX: Invalid port ID"));
} }
return UBX_SEND_FAIL; // Invalid port ID return UBX_SEND_FAIL; // Invalid port ID
} }
// Send the message and wait for acknowledgment if requested // Send the message and wait for acknowledgment if requested
if (checkAck) { if (checkAck) {
return sendMessageWithAck(UBX_CLASS_CFG, UBX_CFG_PRT, cfgPrt.raw, sizeof(cfgPrt), timeout_ms); return sendMessageWithAck(UBX_CLASS_CFG, UBX_CFG_PRT, cfgPrt.raw,
sizeof(cfgPrt), timeout_ms);
} else { } else {
if (sendMessage(UBX_CLASS_CFG, UBX_CFG_PRT, cfgPrt.raw, sizeof(cfgPrt))) { if (sendMessage(UBX_CLASS_CFG, UBX_CFG_PRT, cfgPrt.raw, sizeof(cfgPrt))) {
return UBX_SEND_SUCCESS; return UBX_SEND_SUCCESS;
@ -113,12 +112,10 @@ UBXSendStatus Adafruit_UBX::setUBXOnly(UBXPortId portID, bool checkAck, uint16_t
} }
} }
/*! /*!
* @brief Sets the callback function for UBX messages * @brief Sets the callback function for UBX messages
* @param callback Function pointer to call when a complete UBX message is received * @param callback Function pointer to call when a complete UBX message is
* received
*/ */
void Adafruit_UBX::setMessageCallback(UBXMessageCallback callback) { void Adafruit_UBX::setMessageCallback(UBXMessageCallback callback) {
onUBXMessage = callback; onUBXMessage = callback;
@ -140,7 +137,8 @@ void Adafruit_UBX::resetParser() {
* @param checksumA Reference to store the first checksum byte * @param checksumA Reference to store the first checksum byte
* @param checksumB Reference to store the second checksum byte * @param checksumB Reference to store the second checksum byte
*/ */
void Adafruit_UBX::calculateChecksum(uint8_t *buffer, uint16_t len, uint8_t &checksumA, uint8_t &checksumB) { void Adafruit_UBX::calculateChecksum(uint8_t *buffer, uint16_t len,
uint8_t &checksumA, uint8_t &checksumB) {
checksumA = 0; checksumA = 0;
checksumB = 0; checksumB = 0;
@ -163,143 +161,151 @@ bool Adafruit_UBX::checkMessages() {
// State machine for UBX protocol parsing // State machine for UBX protocol parsing
switch (_parserState) { switch (_parserState) {
case WAIT_SYNC_1: case WAIT_SYNC_1:
if (incomingByte == UBX_SYNC_CHAR_1) { if (incomingByte == UBX_SYNC_CHAR_1) {
_parserState = WAIT_SYNC_2; _parserState = WAIT_SYNC_2;
_buffer[0] = incomingByte; // Store for checksum calculation _buffer[0] = incomingByte; // Store for checksum calculation
}
break;
case WAIT_SYNC_2:
if (incomingByte == UBX_SYNC_CHAR_2) {
_parserState = GET_CLASS;
_buffer[1] = incomingByte; // Store for checksum calculation
} else {
resetParser(); // Invalid sync char, reset
}
break;
case GET_CLASS:
_msgClass = incomingByte;
_buffer[2] = incomingByte; // Store for checksum calculation
_parserState = GET_ID;
break;
case GET_ID:
_msgId = incomingByte;
_buffer[3] = incomingByte; // Store for checksum calculation
_parserState = GET_LENGTH_1;
break;
case GET_LENGTH_1:
_payloadLength = incomingByte;
_buffer[4] = incomingByte; // Store for checksum calculation
_parserState = GET_LENGTH_2;
break;
case GET_LENGTH_2:
_payloadLength |= (incomingByte << 8);
_buffer[5] = incomingByte; // Store for checksum calculation
if (_payloadLength > MAX_PAYLOAD_SIZE) {
resetParser(); // Payload too large, reset
} else {
_payloadCounter = 0;
_parserState = GET_PAYLOAD;
}
break;
case GET_PAYLOAD:
if (_payloadCounter < _payloadLength) {
_buffer[6 + _payloadCounter] = incomingByte;
_payloadCounter++;
if (_payloadCounter == _payloadLength) {
_parserState = GET_CHECKSUM_A;
} }
break; }
break;
case WAIT_SYNC_2: case GET_CHECKSUM_A:
if (incomingByte == UBX_SYNC_CHAR_2) { // Calculate expected checksum
_parserState = GET_CLASS; calculateChecksum(_buffer + 2, _payloadLength + 4, _checksumA,
_buffer[1] = incomingByte; // Store for checksum calculation _checksumB);
} else {
resetParser(); // Invalid sync char, reset if (incomingByte == _checksumA) {
_parserState = GET_CHECKSUM_B; // Checksum A matches
} else {
resetParser(); // Invalid checksum, reset
}
break;
case GET_CHECKSUM_B:
if (incomingByte == _checksumB) {
// We have a valid message!
if (onUBXMessage != NULL) {
onUBXMessage(_msgClass, _msgId, _payloadLength,
_buffer + 6); // Call the callback with the message
} }
break; messageReceived = true;
case GET_CLASS: _lastMsgClass = _msgClass;
_msgClass = incomingByte; _lastMsgId = _msgId;
_buffer[2] = incomingByte; // Store for checksum calculation _lastPayloadLength = _payloadLength;
_parserState = GET_ID;
break;
case GET_ID: // Store a small copy of the payload if it's within size limits
_msgId = incomingByte; if (_payloadLength <= sizeof(_lastPayload)) {
_buffer[3] = incomingByte; // Store for checksum calculation memcpy(_lastPayload, _buffer + 6, _payloadLength);
_parserState = GET_LENGTH_1;
break;
case GET_LENGTH_1:
_payloadLength = incomingByte;
_buffer[4] = incomingByte; // Store for checksum calculation
_parserState = GET_LENGTH_2;
break;
case GET_LENGTH_2:
_payloadLength |= (incomingByte << 8);
_buffer[5] = incomingByte; // Store for checksum calculation
if (_payloadLength > MAX_PAYLOAD_SIZE) {
resetParser(); // Payload too large, reset
} else {
_payloadCounter = 0;
_parserState = GET_PAYLOAD;
} }
break;
case GET_PAYLOAD: if (verbose_debug > 0) {
if (_payloadCounter < _payloadLength) { Serial.print("UBX RX: ");
_buffer[6 + _payloadCounter] = incomingByte;
_payloadCounter++;
if (_payloadCounter == _payloadLength) { // Print header (sync chars, class, id, length)
_parserState = GET_CHECKSUM_A; Serial.print("HDR[B5 62 ");
} if (_msgClass < 0x10)
} Serial.print("0");
break; Serial.print(_msgClass, HEX);
Serial.print(" ");
if (_msgId < 0x10)
Serial.print("0");
Serial.print(_msgId, HEX);
Serial.print(" ");
case GET_CHECKSUM_A: uint8_t lenLSB = _payloadLength & 0xFF;
// Calculate expected checksum uint8_t lenMSB = (_payloadLength >> 8) & 0xFF;
calculateChecksum(_buffer + 2, _payloadLength + 4, _checksumA, _checksumB); if (lenLSB < 0x10)
Serial.print("0");
Serial.print(lenLSB, HEX);
Serial.print(" ");
if (lenMSB < 0x10)
Serial.print("0");
Serial.print(lenMSB, HEX);
Serial.print("] ");
if (incomingByte == _checksumA) { // Print payload if verbose debug is enabled
_parserState = GET_CHECKSUM_B; // Checksum A matches if (verbose_debug > 1 && _payloadLength > 0) {
} else { Serial.print("PL[");
resetParser(); // Invalid checksum, reset for (uint16_t i = 0; i < _payloadLength; i++) {
} if (_buffer[6 + i] < 0x10)
break; Serial.print("0");
Serial.print(_buffer[6 + i], HEX);
case GET_CHECKSUM_B: Serial.print(" ");
if (incomingByte == _checksumB) {
// We have a valid message!
if (onUBXMessage != NULL) {
onUBXMessage(_msgClass, _msgId, _payloadLength, _buffer + 6); // Call the callback with the message
}
messageReceived = true;
_lastMsgClass = _msgClass;
_lastMsgId = _msgId;
_lastPayloadLength = _payloadLength;
// Store a small copy of the payload if it's within size limits
if (_payloadLength <= sizeof(_lastPayload)) {
memcpy(_lastPayload, _buffer + 6, _payloadLength);
}
if (verbose_debug > 0) {
Serial.print("UBX RX: ");
// Print header (sync chars, class, id, length)
Serial.print("HDR[B5 62 ");
if (_msgClass < 0x10) Serial.print("0");
Serial.print(_msgClass, HEX);
Serial.print(" ");
if (_msgId < 0x10) Serial.print("0");
Serial.print(_msgId, HEX);
Serial.print(" ");
uint8_t lenLSB = _payloadLength & 0xFF;
uint8_t lenMSB = (_payloadLength >> 8) & 0xFF;
if (lenLSB < 0x10) Serial.print("0");
Serial.print(lenLSB, HEX);
Serial.print(" ");
if (lenMSB < 0x10) Serial.print("0");
Serial.print(lenMSB, HEX);
Serial.print("] ");
// Print payload if verbose debug is enabled
if (verbose_debug > 1 && _payloadLength > 0) {
Serial.print("PL[");
for (uint16_t i = 0; i < _payloadLength; i++) {
if (_buffer[6 + i] < 0x10) Serial.print("0");
Serial.print(_buffer[6 + i], HEX);
Serial.print(" ");
}
Serial.print("] ");
} }
Serial.print("] ");
// Print checksum
Serial.print("CS[");
if (_checksumA < 0x10) Serial.print("0");
Serial.print(_checksumA, HEX);
Serial.print(" ");
if (_checksumB < 0x10) Serial.print("0");
Serial.print(_checksumB, HEX);
Serial.println("]");
} }
}
resetParser(); // Reset for next message // Print checksum
break; Serial.print("CS[");
if (_checksumA < 0x10)
Serial.print("0");
Serial.print(_checksumA, HEX);
Serial.print(" ");
if (_checksumB < 0x10)
Serial.print("0");
Serial.print(_checksumB, HEX);
Serial.println("]");
}
}
resetParser(); // Reset for next message
break;
} }
} }
return messageReceived; return messageReceived;
} }
/*! /*!
* @brief Send a UBX message and wait for acknowledgment * @brief Send a UBX message and wait for acknowledgment
* @param msgClass Message class * @param msgClass Message class
@ -309,7 +315,10 @@ bool Adafruit_UBX::checkMessages() {
* @param timeout_ms Maximum time to wait for acknowledgment * @param timeout_ms Maximum time to wait for acknowledgment
* @return UBXSendStatus indicating success, failure, or timeout * @return UBXSendStatus indicating success, failure, or timeout
*/ */
UBXSendStatus Adafruit_UBX::sendMessageWithAck(uint8_t msgClass, uint8_t msgId, uint8_t *payload, uint16_t length, uint16_t timeout_ms = 500) { UBXSendStatus Adafruit_UBX::sendMessageWithAck(uint8_t msgClass, uint8_t msgId,
uint8_t *payload,
uint16_t length,
uint16_t timeout_ms = 500) {
// First send the message // First send the message
if (!sendMessage(msgClass, msgId, payload, length)) { if (!sendMessage(msgClass, msgId, payload, length)) {
if (verbose_debug > 0) { if (verbose_debug > 0) {
@ -332,10 +341,12 @@ UBXSendStatus Adafruit_UBX::sendMessageWithAck(uint8_t msgClass, uint8_t msgId,
if (_lastPayload[0] == msgClass && _lastPayload[1] == msgId) { if (_lastPayload[0] == msgClass && _lastPayload[1] == msgId) {
if (verbose_debug > 0) { if (verbose_debug > 0) {
Serial.print(F("UBX ACK: SUCCESS for message class 0x")); Serial.print(F("UBX ACK: SUCCESS for message class 0x"));
if (msgClass < 0x10) Serial.print("0"); if (msgClass < 0x10)
Serial.print("0");
Serial.print(msgClass, HEX); Serial.print(msgClass, HEX);
Serial.print(" ID 0x"); Serial.print(" ID 0x");
if (msgId < 0x10) Serial.print("0"); if (msgId < 0x10)
Serial.print("0");
Serial.println(msgId, HEX); Serial.println(msgId, HEX);
} }
return UBX_SEND_SUCCESS; return UBX_SEND_SUCCESS;
@ -345,10 +356,12 @@ UBXSendStatus Adafruit_UBX::sendMessageWithAck(uint8_t msgClass, uint8_t msgId,
if (_lastPayload[0] == msgClass && _lastPayload[1] == msgId) { if (_lastPayload[0] == msgClass && _lastPayload[1] == msgId) {
if (verbose_debug > 0) { if (verbose_debug > 0) {
Serial.print(F("UBX ACK: NAK for message class 0x")); Serial.print(F("UBX ACK: NAK for message class 0x"));
if (msgClass < 0x10) Serial.print("0"); if (msgClass < 0x10)
Serial.print("0");
Serial.print(msgClass, HEX); Serial.print(msgClass, HEX);
Serial.print(" ID 0x"); Serial.print(" ID 0x");
if (msgId < 0x10) Serial.print("0"); if (msgId < 0x10)
Serial.print("0");
Serial.println(msgId, HEX); Serial.println(msgId, HEX);
} }
return UBX_SEND_NAK; return UBX_SEND_NAK;
@ -362,28 +375,33 @@ UBXSendStatus Adafruit_UBX::sendMessageWithAck(uint8_t msgClass, uint8_t msgId,
} }
if (verbose_debug > 0) { if (verbose_debug > 0) {
Serial.print(F("UBX ACK: TIMEOUT waiting for ACK/NAK for message class 0x")); Serial.print(
if (msgClass < 0x10) Serial.print("0"); F("UBX ACK: TIMEOUT waiting for ACK/NAK for message class 0x"));
if (msgClass < 0x10)
Serial.print("0");
Serial.print(msgClass, HEX); Serial.print(msgClass, HEX);
Serial.print(" ID 0x"); Serial.print(" ID 0x");
if (msgId < 0x10) Serial.print("0"); if (msgId < 0x10)
Serial.print("0");
Serial.println(msgId, HEX); Serial.println(msgId, HEX);
} }
return UBX_SEND_TIMEOUT; return UBX_SEND_TIMEOUT;
} }
/*! /*!
* @brief Send a UBX message to the GPS module * @brief Send a UBX message to the GPS module
* @param msgClass Message class * @param msgClass Message class
* @param msgId Message ID * @param msgId Message ID
* @param payload Pointer to the payload data (can be NULL for zero-length payload) * @param payload Pointer to the payload data (can be NULL for zero-length
* payload)
* @param length Length of payload * @param length Length of payload
* @return True if message was sent successfully * @return True if message was sent successfully
*/ */
bool Adafruit_UBX::sendMessage(uint8_t msgClass, uint8_t msgId, uint8_t *payload, uint16_t length) { bool Adafruit_UBX::sendMessage(uint8_t msgClass, uint8_t msgId,
// Buffer for message (2 sync chars + class + id + 2 length bytes + payload + 2 checksum bytes) uint8_t *payload, uint16_t length) {
// Buffer for message (2 sync chars + class + id + 2 length bytes + payload +
// 2 checksum bytes)
uint8_t msgBuffer[length + 8]; uint8_t msgBuffer[length + 8];
// Sync characters // Sync characters
@ -417,7 +435,8 @@ bool Adafruit_UBX::sendMessage(uint8_t msgClass, uint8_t msgId, uint8_t *payload
// Print header (sync chars, class, id, length) // Print header (sync chars, class, id, length)
Serial.print("HDR["); Serial.print("HDR[");
for (int i = 0; i < 6; i++) { for (int i = 0; i < 6; i++) {
if (msgBuffer[i] < 0x10) Serial.print("0"); if (msgBuffer[i] < 0x10)
Serial.print("0");
Serial.print(msgBuffer[i], HEX); Serial.print(msgBuffer[i], HEX);
Serial.print(" "); Serial.print(" ");
} }
@ -427,7 +446,8 @@ bool Adafruit_UBX::sendMessage(uint8_t msgClass, uint8_t msgId, uint8_t *payload
if (verbose_debug > 1 && length > 0) { if (verbose_debug > 1 && length > 0) {
Serial.print("PL["); Serial.print("PL[");
for (uint16_t i = 0; i < length; i++) { for (uint16_t i = 0; i < length; i++) {
if (msgBuffer[6 + i] < 0x10) Serial.print("0"); if (msgBuffer[6 + i] < 0x10)
Serial.print("0");
Serial.print(msgBuffer[6 + i], HEX); Serial.print(msgBuffer[6 + i], HEX);
Serial.print(" "); Serial.print(" ");
} }
@ -436,10 +456,12 @@ bool Adafruit_UBX::sendMessage(uint8_t msgClass, uint8_t msgId, uint8_t *payload
// Print checksum // Print checksum
Serial.print("CS["); Serial.print("CS[");
if (checksumA < 0x10) Serial.print("0"); if (checksumA < 0x10)
Serial.print("0");
Serial.print(checksumA, HEX); Serial.print(checksumA, HEX);
Serial.print(" "); Serial.print(" ");
if (checksumB < 0x10) Serial.print("0"); if (checksumB < 0x10)
Serial.print("0");
Serial.print(checksumB, HEX); Serial.print(checksumB, HEX);
Serial.println("]"); Serial.println("]");
} }

111
Adafruit_UBX.h
View file

@ -17,82 +17,89 @@
#ifndef ADAFRUIT_UBX_H #ifndef ADAFRUIT_UBX_H
#define ADAFRUIT_UBX_H #define ADAFRUIT_UBX_H
#include "Adafruit_uBlox_typedef.h"
#include <Arduino.h> #include <Arduino.h>
#include <Stream.h> #include <Stream.h>
#include "Adafruit_uBlox_typedef.h"
// UBX protocol constants // UBX protocol constants
#define UBX_SYNC_CHAR_1 0xB5 // First UBX protocol sync char (<28>) #define UBX_SYNC_CHAR_1 0xB5 // First UBX protocol sync char (<28>)
#define UBX_SYNC_CHAR_2 0x62 // Second UBX protocol sync char (b) #define UBX_SYNC_CHAR_2 0x62 // Second UBX protocol sync char (b)
// UBX ACK Message IDs // UBX ACK Message IDs
#define UBX_ACK_NAK 0x00 // Message Not Acknowledged #define UBX_ACK_NAK 0x00 // Message Not Acknowledged
#define UBX_ACK_ACK 0x01 // Message Acknowledged #define UBX_ACK_ACK 0x01 // Message Acknowledged
// Callback function type for UBX messages - defined at global scope so other classes can use it
typedef void (*UBXMessageCallback)(uint8_t msgClass, uint8_t msgId, uint16_t payloadLen, uint8_t *payload);
// Callback function type for UBX messages - defined at global scope so other
// classes can use it
typedef void (*UBXMessageCallback)(uint8_t msgClass, uint8_t msgId,
uint16_t payloadLen, uint8_t *payload);
/*! /*!
* @brief Class for parsing UBX protocol messages from u-blox GPS/RTK modules * @brief Class for parsing UBX protocol messages from u-blox GPS/RTK modules
*/ */
class Adafruit_UBX { class Adafruit_UBX {
public: public:
// Constructor // Constructor
Adafruit_UBX(Stream &stream); Adafruit_UBX(Stream &stream);
uint8_t verbose_debug = 0; // 0=off, 1=basic, 2=verbose uint8_t verbose_debug = 0; // 0=off, 1=basic, 2=verbose
// Basic methods // Basic methods
bool begin(); bool begin();
bool checkMessages(); // Message parsing bool checkMessages(); // Message parsing
bool sendMessage(uint8_t msgClass, uint8_t msgId, uint8_t *payload, uint16_t length); // Send a UBX message bool sendMessage(uint8_t msgClass, uint8_t msgId, uint8_t *payload,
UBXSendStatus sendMessageWithAck(uint8_t msgClass, uint8_t msgId, uint8_t *payload, uint16_t length, uint16_t timeout_ms = 500); uint16_t length); // Send a UBX message
UBXSendStatus sendMessageWithAck(uint8_t msgClass, uint8_t msgId,
uint8_t *payload, uint16_t length,
uint16_t timeout_ms = 500);
// Configure port to use UBX protocol only (disable NMEA) // Configure port to use UBX protocol only (disable NMEA)
UBXSendStatus setUBXOnly(UBXPortId portID, bool checkAck = true, uint16_t timeout_ms = 500); UBXSendStatus setUBXOnly(UBXPortId portID, bool checkAck = true,
uint16_t timeout_ms = 500);
void setMessageCallback(UBXMessageCallback callback); // Set callback function void setMessageCallback(UBXMessageCallback callback); // Set callback function
UBXMessageCallback onUBXMessage; // Callback for message received UBXMessageCallback onUBXMessage; // Callback for message received
private: private:
Stream *_stream; // Stream interface for reading data Stream *_stream; // Stream interface for reading data
// Buffer for reading messages // Buffer for reading messages
static const uint16_t MAX_PAYLOAD_SIZE = 64; // Maximum UBX payload size static const uint16_t MAX_PAYLOAD_SIZE = 64; // Maximum UBX payload size
uint8_t _buffer[MAX_PAYLOAD_SIZE + 8]; // Buffer for message (header, payload, checksum) uint8_t _buffer[MAX_PAYLOAD_SIZE +
8]; // Buffer for message (header, payload, checksum)
// Parser state machine // Parser state machine
enum ParserState { enum ParserState {
WAIT_SYNC_1, // Waiting for first sync char (0xB5) WAIT_SYNC_1, // Waiting for first sync char (0xB5)
WAIT_SYNC_2, // Waiting for second sync char (0x62) WAIT_SYNC_2, // Waiting for second sync char (0x62)
GET_CLASS, // Reading message class GET_CLASS, // Reading message class
GET_ID, // Reading message ID GET_ID, // Reading message ID
GET_LENGTH_1, // Reading length LSB GET_LENGTH_1, // Reading length LSB
GET_LENGTH_2, // Reading length MSB GET_LENGTH_2, // Reading length MSB
GET_PAYLOAD, // Reading payload GET_PAYLOAD, // Reading payload
GET_CHECKSUM_A, // Reading checksum A GET_CHECKSUM_A, // Reading checksum A
GET_CHECKSUM_B // Reading checksum B GET_CHECKSUM_B // Reading checksum B
}; };
ParserState _parserState = WAIT_SYNC_1; // Current state of the parser ParserState _parserState = WAIT_SYNC_1; // Current state of the parser
uint8_t _msgClass; // Message class of current message uint8_t _msgClass; // Message class of current message
uint8_t _msgId; // Message ID of current message uint8_t _msgId; // Message ID of current message
uint16_t _payloadLength; // Length of current message payload uint16_t _payloadLength; // Length of current message payload
uint16_t _payloadCounter; // Counter for payload bytes received uint16_t _payloadCounter; // Counter for payload bytes received
uint8_t _checksumA; // Running checksum A uint8_t _checksumA; // Running checksum A
uint8_t _checksumB; // Running checksum B uint8_t _checksumB; // Running checksum B
// Calculate checksum for a block of data // Calculate checksum for a block of data
void calculateChecksum(uint8_t *buffer, uint16_t len, uint8_t &checksumA, uint8_t &checksumB); void calculateChecksum(uint8_t *buffer, uint16_t len, uint8_t &checksumA,
uint8_t &checksumB);
// Reset parser state // Reset parser state
void resetParser(); void resetParser();
// Add to private section of Adafruit_UBX.h // Add to private section of Adafruit_UBX.h
uint8_t _lastMsgClass; // Class of last message uint8_t _lastMsgClass; // Class of last message
uint8_t _lastMsgId; // ID of last message uint8_t _lastMsgId; // ID of last message
uint16_t _lastPayloadLength; // Length of last message payload uint16_t _lastPayloadLength; // Length of last message payload
uint8_t _lastPayload[8]; // Buffer for small payloads (like ACK messages) uint8_t _lastPayload[8]; // Buffer for small payloads (like ACK messages)
}; };
#endif // ADAFRUIT_UBX_H #endif // ADAFRUIT_UBX_H

20
Adafruit_UBloxDDC.cpp
View file

@ -50,9 +50,7 @@ Adafruit_UBloxDDC::~Adafruit_UBloxDDC() {
* @brief Initializes the GPS module and I2C interface * @brief Initializes the GPS module and I2C interface
* @return True if GPS module responds, false on any failure * @return True if GPS module responds, false on any failure
*/ */
bool Adafruit_UBloxDDC::begin() { bool Adafruit_UBloxDDC::begin() { return _i2cDevice->begin(); }
return _i2cDevice->begin();
}
/*! /*!
* @brief Gets the number of bytes available for reading * @brief Gets the number of bytes available for reading
@ -62,7 +60,8 @@ int Adafruit_UBloxDDC::available() {
uint8_t buffer[2]; uint8_t buffer[2];
// Create a register for reading bytes available // Create a register for reading bytes available
Adafruit_BusIO_Register bytesAvailableReg = Adafruit_BusIO_Register(_i2cDevice, REG_BYTES_AVAILABLE_MSB, 2); Adafruit_BusIO_Register bytesAvailableReg =
Adafruit_BusIO_Register(_i2cDevice, REG_BYTES_AVAILABLE_MSB, 2);
if (!bytesAvailableReg.read(buffer, 2)) { if (!bytesAvailableReg.read(buffer, 2)) {
return 0; return 0;
@ -88,7 +87,8 @@ int Adafruit_UBloxDDC::read() {
uint8_t value; uint8_t value;
// Create a register for the data stream // Create a register for the data stream
Adafruit_BusIO_Register dataStreamReg = Adafruit_BusIO_Register(_i2cDevice, REG_DATA_STREAM, 1); Adafruit_BusIO_Register dataStreamReg =
Adafruit_BusIO_Register(_i2cDevice, REG_DATA_STREAM, 1);
if (!dataStreamReg.read(&value, 1)) { if (!dataStreamReg.read(&value, 1)) {
return -1; return -1;
@ -153,7 +153,7 @@ size_t Adafruit_UBloxDDC::write(const uint8_t *buffer, size_t size) {
* @param length Maximum number of bytes to read * @param length Maximum number of bytes to read
* @return Number of bytes actually read, which may be less than requested * @return Number of bytes actually read, which may be less than requested
*/ */
uint16_t Adafruit_UBloxDDC::readBytes(uint8_t* buffer, uint16_t length) { uint16_t Adafruit_UBloxDDC::readBytes(uint8_t *buffer, uint16_t length) {
if (buffer == nullptr || length == 0) { if (buffer == nullptr || length == 0) {
return 0; return 0;
} }
@ -176,7 +176,8 @@ uint16_t Adafruit_UBloxDDC::readBytes(uint8_t* buffer, uint16_t length) {
} }
// Create a register for the data stream // Create a register for the data stream
Adafruit_BusIO_Register dataStreamReg = Adafruit_BusIO_Register(_i2cDevice, REG_DATA_STREAM, 1); Adafruit_BusIO_Register dataStreamReg =
Adafruit_BusIO_Register(_i2cDevice, REG_DATA_STREAM, 1);
while (bytesRead < length) { while (bytesRead < length) {
// Calculate chunk size (I2C has a limit on bytes per transfer) // Calculate chunk size (I2C has a limit on bytes per transfer)
@ -198,7 +199,7 @@ uint16_t Adafruit_UBloxDDC::readBytes(uint8_t* buffer, uint16_t length) {
* @param maxLength Maximum length of buffer * @param maxLength Maximum length of buffer
* @return Number of bytes read into the buffer * @return Number of bytes read into the buffer
*/ */
uint16_t Adafruit_UBloxDDC::readMessage(uint8_t* buffer, uint16_t maxLength) { uint16_t Adafruit_UBloxDDC::readMessage(uint8_t *buffer, uint16_t maxLength) {
uint16_t bytesAvailable = available(); uint16_t bytesAvailable = available();
if (bytesAvailable == 0) { if (bytesAvailable == 0) {
@ -215,8 +216,7 @@ uint16_t Adafruit_UBloxDDC::readMessage(uint8_t* buffer, uint16_t maxLength) {
* @param messageLength Pointer to variable to store message length * @param messageLength Pointer to variable to store message length
* @return Pointer to internal buffer containing the message * @return Pointer to internal buffer containing the message
*/ */
uint8_t* Adafruit_UBloxDDC::readMessage(uint16_t* messageLength) { uint8_t *Adafruit_UBloxDDC::readMessage(uint16_t *messageLength) {
*messageLength = readMessage(_buffer, MAX_BUFFER_SIZE); *messageLength = readMessage(_buffer, MAX_BUFFER_SIZE);
return _buffer; return _buffer;
} }

66
Adafruit_UBloxDDC.h
View file

@ -18,51 +18,55 @@
#ifndef ADAFRUIT_UBLOXDDC_H #ifndef ADAFRUIT_UBLOXDDC_H
#define ADAFRUIT_UBLOXDDC_H #define ADAFRUIT_UBLOXDDC_H
#include <Arduino.h>
#include <Stream.h>
#include <Adafruit_BusIO_Register.h> #include <Adafruit_BusIO_Register.h>
#include <Adafruit_I2CDevice.h> #include <Adafruit_I2CDevice.h>
#include <Arduino.h>
#include <Stream.h>
/*! /*!
* @brief Arduino library for interfacing with u-blox GPS/RTK modules over I2C * @brief Arduino library for interfacing with u-blox GPS/RTK modules over I2C
*/ */
class Adafruit_UBloxDDC : public Stream { class Adafruit_UBloxDDC : public Stream {
private: private:
Adafruit_I2CDevice *_i2cDevice; ///< Underlying I2C device Adafruit_I2CDevice *_i2cDevice; ///< Underlying I2C device
// Register addresses // Register addresses
static const uint8_t REG_DATA_STREAM = 0xFF; ///< Register for reading data stream static const uint8_t REG_DATA_STREAM =
static const uint8_t REG_BYTES_AVAILABLE_MSB = 0xFD; ///< MSB of bytes available 0xFF; ///< Register for reading data stream
static const uint8_t REG_BYTES_AVAILABLE_LSB = 0xFE; ///< LSB of bytes available static const uint8_t REG_BYTES_AVAILABLE_MSB =
0xFD; ///< MSB of bytes available
static const uint8_t REG_BYTES_AVAILABLE_LSB =
0xFE; ///< LSB of bytes available
// Buffer for reading messages // Buffer for reading messages
static const uint16_t MAX_BUFFER_SIZE = 128; ///< Maximum buffer size for messages static const uint16_t MAX_BUFFER_SIZE =
uint8_t _buffer[MAX_BUFFER_SIZE]; ///< Internal buffer for messages 128; ///< Maximum buffer size for messages
uint8_t _buffer[MAX_BUFFER_SIZE]; ///< Internal buffer for messages
// Last byte read for peek() implementation // Last byte read for peek() implementation
int _lastByte = -1; ///< Last byte read by peek() int _lastByte = -1; ///< Last byte read by peek()
bool _hasPeeked = false; ///< Indicates if we have a peeked byte waiting bool _hasPeeked = false; ///< Indicates if we have a peeked byte waiting
public: public:
// Constructor & destructor // Constructor & destructor
Adafruit_UBloxDDC(uint8_t address = 0x42, TwoWire *wire = &Wire); Adafruit_UBloxDDC(uint8_t address = 0x42, TwoWire *wire = &Wire);
~Adafruit_UBloxDDC(); ~Adafruit_UBloxDDC();
// Basic methods // Basic methods
bool begin(); bool begin();
// Stream interface implementation // Stream interface implementation
virtual int available() override; virtual int available() override;
virtual int read() override; virtual int read() override;
virtual int peek() override; virtual int peek() override;
// Stream interface implementation // Stream interface implementation
virtual size_t write(uint8_t) override; virtual size_t write(uint8_t) override;
virtual size_t write(const uint8_t *buffer, size_t size) override; virtual size_t write(const uint8_t *buffer, size_t size) override;
// Additional methods // Additional methods
uint16_t readBytes(uint8_t* buffer, uint16_t length); uint16_t readBytes(uint8_t *buffer, uint16_t length);
uint16_t readMessage(uint8_t* buffer, uint16_t maxLength); uint16_t readMessage(uint8_t *buffer, uint16_t maxLength);
uint8_t* readMessage(uint16_t* messageLength); uint8_t *readMessage(uint16_t *messageLength);
}; };
#endif // ADAFRUIT_UBLOXDDC_H #endif // ADAFRUIT_UBLOXDDC_H

45
Adafruit_uBlox_Ubx_Messages.h
View file

@ -18,28 +18,41 @@
#include <Arduino.h> #include <Arduino.h>
// NMEA Message Configuration Commands (CFG-MSG) // NMEA Message Configuration Commands (CFG-MSG)
// Format: {msgClass, msgID, rate_I2C, rate_UART1, rate_UART2, rate_USB, rate_SPI, reserved} // Format: {msgClass, msgID, rate_I2C, rate_UART1, rate_UART2, rate_USB,
// rate_SPI, reserved}
// Enable specific NMEA message sentences to output on the DDC interface // Enable specific NMEA message sentences to output on the DDC interface
static uint8_t UBX_CFG_MSG_NMEA_GGA_ENABLE[] = {0xF0, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}; static uint8_t UBX_CFG_MSG_NMEA_GGA_ENABLE[] = {0xF0, 0x00, 0x01, 0x00,
static uint8_t UBX_CFG_MSG_NMEA_GLL_ENABLE[] = {0xF0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_GSA_ENABLE[] = {0xF0, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}; static uint8_t UBX_CFG_MSG_NMEA_GLL_ENABLE[] = {0xF0, 0x01, 0x01, 0x00,
static uint8_t UBX_CFG_MSG_NMEA_GSV_ENABLE[] = {0xF0, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_RMC_ENABLE[] = {0xF0, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}; static uint8_t UBX_CFG_MSG_NMEA_GSA_ENABLE[] = {0xF0, 0x02, 0x01, 0x00,
static uint8_t UBX_CFG_MSG_NMEA_VTG_ENABLE[] = {0xF0, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_GSV_ENABLE[] = {0xF0, 0x03, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_RMC_ENABLE[] = {0xF0, 0x04, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_VTG_ENABLE[] = {0xF0, 0x05, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00};
// Disable specific NMEA message sentences from outputting on the DDC interface // Disable specific NMEA message sentences from outputting on the DDC interface
static uint8_t UBX_CFG_MSG_NMEA_GGA_DISABLE[] = {0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; static uint8_t UBX_CFG_MSG_NMEA_GGA_DISABLE[] = {0xF0, 0x00, 0x00, 0x00,
static uint8_t UBX_CFG_MSG_NMEA_GLL_DISABLE[] = {0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_GSA_DISABLE[] = {0xF0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; static uint8_t UBX_CFG_MSG_NMEA_GLL_DISABLE[] = {0xF0, 0x01, 0x00, 0x00,
static uint8_t UBX_CFG_MSG_NMEA_GSV_DISABLE[] = {0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_RMC_DISABLE[] = {0xF0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; static uint8_t UBX_CFG_MSG_NMEA_GSA_DISABLE[] = {0xF0, 0x02, 0x00, 0x00,
static uint8_t UBX_CFG_MSG_NMEA_VTG_DISABLE[] = {0xF0, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_GSV_DISABLE[] = {0xF0, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_RMC_DISABLE[] = {0xF0, 0x04, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00};
static uint8_t UBX_CFG_MSG_NMEA_VTG_DISABLE[] = {0xF0, 0x05, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00};
// Navigation Rate Configuration Commands (CFG-RATE) // Navigation Rate Configuration Commands (CFG-RATE)
// Format: {measRate_ms (2 bytes), navRate, timeRef} // Format: {measRate_ms (2 bytes), navRate, timeRef}
static uint8_t UBX_CFG_RATE_1HZ[] = {0xE8, 0x03, 0x01, 0x00, 0x01, 0x00}; static uint8_t UBX_CFG_RATE_1HZ[] = {0xE8, 0x03, 0x01, 0x00, 0x01, 0x00};
static uint8_t UBX_CFG_RATE_2HZ[] = {0xF4, 0x01, 0x01, 0x00, 0x01, 0x00}; static uint8_t UBX_CFG_RATE_2HZ[] = {0xF4, 0x01, 0x01, 0x00, 0x01, 0x00};
static uint8_t UBX_CFG_RATE_5HZ[] = {0xC8, 0x00, 0x01, 0x00, 0x01, 0x00}; static uint8_t UBX_CFG_RATE_5HZ[] = {0xC8, 0x00, 0x01, 0x00, 0x01, 0x00};
static uint8_t UBX_CFG_RATE_10HZ[] = {0x64, 0x00, 0x01, 0x00, 0x01, 0x00}; static uint8_t UBX_CFG_RATE_10HZ[] = {0x64, 0x00, 0x01, 0x00, 0x01, 0x00};
#endif // ADAFRUIT_UBLOX_UBX_MESSAGES #endif // ADAFRUIT_UBLOX_UBX_MESSAGES

71
Adafruit_uBlox_typedef.h
View file

@ -19,41 +19,41 @@
// UBX Message Classes // UBX Message Classes
typedef enum { typedef enum {
UBX_CLASS_NAV = 0x01, // Navigation Results UBX_CLASS_NAV = 0x01, // Navigation Results
UBX_CLASS_RXM = 0x02, // Receiver Manager Messages UBX_CLASS_RXM = 0x02, // Receiver Manager Messages
UBX_CLASS_INF = 0x04, // Information Messages UBX_CLASS_INF = 0x04, // Information Messages
UBX_CLASS_ACK = 0x05, // Acknowledgements UBX_CLASS_ACK = 0x05, // Acknowledgements
UBX_CLASS_CFG = 0x06, // Configuration UBX_CLASS_CFG = 0x06, // Configuration
UBX_CLASS_UPD = 0x09, // Firmware Update UBX_CLASS_UPD = 0x09, // Firmware Update
UBX_CLASS_MON = 0x0A, // Monitoring UBX_CLASS_MON = 0x0A, // Monitoring
UBX_CLASS_AID = 0x0B, // AssistNow Aiding UBX_CLASS_AID = 0x0B, // AssistNow Aiding
UBX_CLASS_TIM = 0x0D, // Timing UBX_CLASS_TIM = 0x0D, // Timing
UBX_CLASS_ESF = 0x10, // External Sensor Fusion UBX_CLASS_ESF = 0x10, // External Sensor Fusion
UBX_CLASS_MGA = 0x13, // Multiple GNSS Assistance UBX_CLASS_MGA = 0x13, // Multiple GNSS Assistance
UBX_CLASS_LOG = 0x21, // Logging UBX_CLASS_LOG = 0x21, // Logging
UBX_CLASS_SEC = 0x27, // Security UBX_CLASS_SEC = 0x27, // Security
UBX_CLASS_HNR = 0x28, // High Rate Navigation UBX_CLASS_HNR = 0x28, // High Rate Navigation
UBX_CLASS_NMEA = 0xF0 // NMEA Standard Messages UBX_CLASS_NMEA = 0xF0 // NMEA Standard Messages
} UBXMessageClass; } UBXMessageClass;
// UBX CFG Message IDs // UBX CFG Message IDs
typedef enum { typedef enum {
UBX_CFG_PRT = 0x00, // Port Configuration UBX_CFG_PRT = 0x00, // Port Configuration
UBX_CFG_MSG = 0x01, // Message Configuration UBX_CFG_MSG = 0x01, // Message Configuration
UBX_CFG_RST = 0x04, // Reset Receiver UBX_CFG_RST = 0x04, // Reset Receiver
UBX_CFG_RATE = 0x08, // Navigation/Measurement Rate Settings UBX_CFG_RATE = 0x08, // Navigation/Measurement Rate Settings
UBX_CFG_CFG = 0x09, // Clear, Save, and Load Configurations UBX_CFG_CFG = 0x09, // Clear, Save, and Load Configurations
UBX_CFG_NAVX5 = 0x23, // Navigation Engine Settings UBX_CFG_NAVX5 = 0x23, // Navigation Engine Settings
UBX_CFG_GNSS = 0x3E, // GNSS Configuration UBX_CFG_GNSS = 0x3E, // GNSS Configuration
UBX_CFG_PMS = 0x86 // Power Mode Setup UBX_CFG_PMS = 0x86 // Power Mode Setup
} UBXCfgMessageId; } UBXCfgMessageId;
// Return values for functions that wait for acknowledgment // Return values for functions that wait for acknowledgment
typedef enum { typedef enum {
UBX_SEND_SUCCESS = 0, // Message was acknowledged (ACK) UBX_SEND_SUCCESS = 0, // Message was acknowledged (ACK)
UBX_SEND_NAK, // Message was not acknowledged (NAK) UBX_SEND_NAK, // Message was not acknowledged (NAK)
UBX_SEND_FAIL, // Failed to send the message UBX_SEND_FAIL, // Failed to send the message
UBX_SEND_TIMEOUT // Timed out waiting for ACK/NAK UBX_SEND_TIMEOUT // Timed out waiting for ACK/NAK
} UBXSendStatus; } UBXSendStatus;
// Port ID enum for different interfaces // Port ID enum for different interfaces
@ -82,20 +82,21 @@ typedef enum {
} UBXUARTMode; } UBXUARTMode;
// Protocol flags for inProtoMask and outProtoMask // Protocol flags for inProtoMask and outProtoMask
#define UBX_PROTOCOL_UBX 0x0001 // UBX protocol #define UBX_PROTOCOL_UBX 0x0001 // UBX protocol
#define UBX_PROTOCOL_NMEA 0x0002 // NMEA protocol #define UBX_PROTOCOL_NMEA 0x0002 // NMEA protocol
#define UBX_PROTOCOL_RTCM 0x0004 // RTCM2 protocol (only for inProtoMask) #define UBX_PROTOCOL_RTCM 0x0004 // RTCM2 protocol (only for inProtoMask)
#define UBX_PROTOCOL_RTCM3 0x0020 // RTCM3 protocol #define UBX_PROTOCOL_RTCM3 0x0020 // RTCM3 protocol
// CFG-PRT (Port Configuration) Message // CFG-PRT (Port Configuration) Message
// Total size: 20 bytes // Total size: 20 bytes
typedef union { typedef union {
struct { struct {
uint8_t portID; // Port identifier (0=DDC/I2C, 1=UART1, 2=UART2, 3=USB, 4=SPI) uint8_t
uint8_t reserved1; // Reserved portID; // Port identifier (0=DDC/I2C, 1=UART1, 2=UART2, 3=USB, 4=SPI)
uint16_t txReady; // TX ready PIN configuration uint8_t reserved1; // Reserved
uint32_t mode; // UART mode (bit field) or Reserved for non-UART ports uint16_t txReady; // TX ready PIN configuration
uint32_t baudRate; // Baudrate in bits/second (UART only) uint32_t mode; // UART mode (bit field) or Reserved for non-UART ports
uint32_t baudRate; // Baudrate in bits/second (UART only)
uint16_t inProtoMask; // Input protocol mask uint16_t inProtoMask; // Input protocol mask
uint16_t outProtoMask; // Output protocol mask uint16_t outProtoMask; // Output protocol mask
uint16_t flags; // Flags bit field uint16_t flags; // Flags bit field