PLease rewrite the file from the URL to be complatible with esp-idf framework:…
- User
PLease rewrite the file from the URL to be complatible with esp-idf framework: https://raw.githubusercontent.com/sparkfun/SparkFun_LG290P_GNSS_Arduino_Library/ac7e0aaeb98b8b5dc0c12b4c204d55ce46367111/src/SparkFun_LG290P_GNSS.cpp
Assistant
Okay, let's adapt the SparkFun LG290P GNSS Arduino library (
.cppfile) for the ESP-IDF framework.This involves replacing Arduino-specific functions (
delay,millis,Serial,SoftwareSerial,String) with their ESP-IDF equivalents (vTaskDelay,esp_timer_get_time,ESP_LOGx,driver/uart,chararrays/std::vector).First, we need a header file (
.h) to declare the class and its members.
1. Header File (
sparkfun_lg290p_gnss.h)#ifndef SPARKFUN_LG290P_GNSS_H #define SPARKFUN_LG290P_GNSS_H #include "driver/uart.h" #include <stdint.h> // For standard integer types #include <stdbool.h> // For bool type #include <vector> // For std::vector #include <string> // For std::string // Define default values if not provided via configuration #define LG290P_DEFAULT_BAUD_RATE 9600 #define LG290P_DEFAULT_RX_BUFFER_SIZE 2048 #define LG290P_DEFAULT_NMEA_BUFFER_SIZE 256 // Structure to hold parsed GGA data typedef struct { double latitude; double longitude; double altitude; uint8_t fixQuality; uint8_t satellites; double hdop; // Add other fields as needed (UTC time, etc.) } nmea_gga_t; // Structure to hold parsed RMC data typedef struct { double latitude; double longitude; double speedKnots; // Speed over ground in knots double courseDegrees; // Course over ground in degrees // Add other fields as needed (UTC time, date, status, etc.) } nmea_rmc_t; // Define invalid values (similar to Arduino library) #define INVALID_GPS_VAL -9999.99 class SparkFun_LG290P_GNSS { public: /** * @brief Constructor */ SparkFun_LG290P_GNSS(); /** * @brief Initializes the GNSS module via UART. * @param uart_num The UART port number (e.g., UART_NUM_1). * @param rx_pin The GPIO pin connected to the GNSS module's TX. * @param tx_pin The GPIO pin connected to the GNSS module's RX. * @param baud_rate The communication baud rate (default: 9600). * @param rx_buffer_size Size of the UART driver's internal RX buffer. * @return true if initialization was successful, false otherwise. */ bool begin(uart_port_t uart_num, int rx_pin, int tx_pin, uint32_t baud_rate = LG290P_DEFAULT_BAUD_RATE, size_t rx_buffer_size = LG290P_DEFAULT_RX_BUFFER_SIZE); /** * @brief Stops the UART driver and frees resources. */ void stop(); /** * @brief Checks if data is available from the GNSS module. * @return Number of bytes available in the buffer. */ int available(); /** * @brief Reads a single byte from the GNSS module's buffer. * Handles timing and buffering internally. * @return The byte read, or -1 if no data is available within the timeout. */ int read(); /** * @brief Writes data to the GNSS module. * @param data The byte to write. * @return Number of bytes written (should be 1 on success). */ int write(uint8_t data); /** * @brief Writes a buffer of data to the GNSS module. * @param buffer Pointer to the data buffer. * @param size Number of bytes to write. * @return Number of bytes written. */ int write(const uint8_t *buffer, size_t size); /** * @brief Waits until the UART transmit buffer is empty. */ void flush(); /** * @brief Reads a complete NMEA sentence from the buffer. * Reads bytes until a newline ('\n') is encountered or a timeout occurs. * @param sentenceBuffer Buffer to store the NMEA sentence. * @param bufferSize Size of the sentenceBuffer. * @param timeout_ms Timeout in milliseconds to wait for the sentence. * @return true if a sentence was successfully read, false otherwise. */ bool readNMEA(char *sentenceBuffer, size_t bufferSize, uint32_t timeout_ms = 1000); /** * @brief Parses a GGA NMEA sentence. * @param sentence The NMEA sentence string (e.g., "$GPGGA,..."). * @param ggaData Pointer to the nmea_gga_t struct to fill. * @return true if parsing was successful, false otherwise. */ bool parseGGA(const char *sentence, nmea_gga_t *ggaData); /** * @brief Parses an RMC NMEA sentence. * @param sentence The NMEA sentence string (e.g., "$GPRMC,..."). * @param rmcData Pointer to the nmea_rmc_t struct to fill. * @return true if parsing was successful, false otherwise. */ bool parseRMC(const char *sentence, nmea_rmc_t *rmcData); /** * @brief Converts NMEA latitude/longitude format to decimal degrees. * NMEA Format: ddmm.mmmm (e.g., 4035.7891) * @param nmeaLatLon NMEA formatted latitude or longitude string. * @return Decimal degrees value, or INVALID_GPS_VAL on error. */ double nmeaToDecimalDegrees(const char *nmeaLatLon); /** * @brief Converts NMEA UTC time format to seconds since midnight. * NMEA Format: hhmmss.ss (e.g., 142805.00) * @param nmeaTime NMEA formatted time string. * @return Seconds since midnight, or -1 on error. */ int nmeaTimeToSeconds(const char *nmeaTime); /** * @brief Converts NMEA date format to days since epoch (simplified). * NMEA Format: ddmmyy (e.g., 210623) * @param nmeaDate NMEA formatted date string. * @return Days since epoch (e.g., 21st June 2023 = some_value), or -1 on error. * Note: A full date conversion might be complex depending on the epoch needed. * This example returns days since Jan 1, 2000 for simplicity. */ int nmeaDateToDays(const char* nmeaDate); private: uart_port_t _uart_num = UART_NUM_MAX; // Invalid UART port initially int _rx_pin = -1; int _tx_pin = -1; size_t _rx_buffer_size = LG290P_DEFAULT_RX_BUFFER_SIZE; uint8_t *_rx_buffer = nullptr; // ESP-IDF UART driver buffer size_t _rx_buffer_read_pos = 0; // Tracks position within the driver's buffer read // Ring buffer for byte-by-byte reading to mimic Arduino Stream static const size_t RING_BUFFER_SIZE = 64; uint8_t _ringBuffer[RING_BUFFER_SIZE]; volatile size_t _ringWritePos = 0; volatile size_t _ringReadPos = 0; volatile size_t _ringCount = 0; unsigned long _lastCharTimeMs = 0; // Tracks time for timeouts // Helper to get current time in milliseconds static unsigned long getMillis(); // Helper function to add byte to ring buffer bool _ringBufferPush(uint8_t data); // Helper function to read byte from ring buffer int _ringBufferPop(); // Internal method to check and refill the ring buffer from UART driver void _checkAndRefillRingBuffer(); }; #endif // SPARKFUN_LG290P_GNSS_H
2. Source File (
sparkfun_lg290p_gnss.cpp)#include "sparkfun_lg290p_gnss.h" #include "esp_log.h" #include "esp_check.h" // For ESP_RETURN_ON_ERROR / ESP_RETURN_ON_FALSE #include <string.h> // For strcmp, strncpy, strtok_r #include <stdlib.h> // For atof, atoi #include <stdio.h> // For sscanf static const char *TAG = "LG290P"; // --- Helper Functions --- // Get time in milliseconds using ESP timer unsigned long SparkFun_LG290P_GNSS::getMillis() { // esp_timer_get_time() returns microseconds return (unsigned long)(esp_timer_get_time() / 1000ULL); } // Ring buffer push (non-blocking) bool SparkFun_LG290P_GNSS::_ringBufferPush(uint8_t data) { if (_ringCount >= RING_BUFFER_SIZE) { ESP_LOGW(TAG, "Ring buffer overflow!"); return false; // Buffer is full } _ringBuffer[_ringWritePos] = data; _ringWritePos = (_ringWritePos + 1) % RING_BUFFER_SIZE; _ringCount++; return true; } // Ring buffer pop (non-blocking) int SparkFun_LG290P_GNSS::_ringBufferPop() { if (_ringCount == 0) { return -1; // Buffer is empty } uint8_t data = _ringBuffer[_ringReadPos]; _ringReadPos = (_ringReadPos + 1) % RING_BUFFER_SIZE; _ringCount--; return (int)data; } // Check UART driver buffer and fill ring buffer void SparkFun_LG290P_GNSS::_checkAndRefillRingBuffer() { if (_uart_num >= UART_NUM_MAX) { return; // Not initialized } // Check how many bytes are available in the UART driver's buffer size_t buffered_size; esp_err_t ret = uart_get_buffered_data_len(_uart_num, &buffered_size); if (ret != ESP_OK || buffered_size == 0) { return; // No data or error } // Read available bytes from UART driver into a temporary buffer size_t bytes_to_read = buffered_size; // Ensure we don't read more than fits in temporary storage + ring buffer space if (bytes_to_read > RING_BUFFER_SIZE - _ringCount) { bytes_to_read = RING_BUFFER_SIZE - _ringCount; } if (bytes_to_read == 0) return; // No space left in ring buffer // Use a temporary buffer to read from UART driver // Allocate temporary buffer dynamically. Size is limited by available space in ring buffer. uint8_t *temp_buffer = (uint8_t*)malloc(bytes_to_read); if (!temp_buffer) { ESP_LOGE(TAG, "Failed to allocate temp buffer for UART read"); return; } // Read bytes from UART driver. Use a small timeout to avoid blocking indefinitely if state is odd. // Setting timeout to 0 makes it non-blocking. int read_count = uart_read_bytes(_uart_num, temp_buffer, bytes_to_read, pdMS_TO_TICKS(10)); // Small timeout if (read_count > 0) { // Push the read bytes into the ring buffer for (int i = 0; i < read_count; ++i) { _ringBufferPush(temp_buffer[i]); } } else if (read_count < 0) { ESP_LOGE(TAG, "Error reading from UART %d", _uart_num); } // else read_count == 0 means timeout occurred, which is okay if we checked available length free(temp_buffer); } // --- Class Methods --- SparkFun_LG290P_GNSS::SparkFun_LG290P_GNSS() { // Initialize members to default states _uart_num = UART_NUM_MAX; _rx_pin = -1; _tx_pin = -1; _rx_buffer = nullptr; _rx_buffer_read_pos = 0; _ringWritePos = 0; _ringReadPos = 0; _ringCount = 0; _lastCharTimeMs = 0; } bool SparkFun_LG290P_GNSS::begin(uart_port_t uart_num, int rx_pin, int tx_pin, uint32_t baud_rate, size_t rx_buffer_size) { if (uart_num >= UART_NUM_MAX || rx_pin < 0 || tx_pin < 0) { ESP_LOGE(TAG, "Invalid UART port or pins provided."); return false; } _uart_num = uart_num; _rx_pin = rx_pin; _tx_pin = tx_pin; _rx_buffer_size = rx_buffer_size; // Configure UART parameters uart_config_t uart_config = { .baud_rate = baud_rate, .data_bit = UART_DATA_8_BIT, .parity = UART_PARITY_DISABLE, .stop_bit = UART_STOP_BIT_1, .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, .source_clk = UART_SCLK_APB, }; esp_err_t ret; // Configure UART parameters ret = uart_param_config(_uart_num, &uart_config); if (ret != ESP_OK) { ESP_LOGE(TAG, "UART param config failed: %s", esp_err_to_name(ret)); _uart_num = UART_NUM_MAX; // Reset state return false; } // Install UART driver, and get the queue. // We don't strictly need the event queue for this library's logic, // but the driver requires it. Set queue size to 0 if events are not needed. // Let's use a small queue size just in case. ret = uart_driver_install(_uart_num, _rx_buffer_size, 0, 0, NULL, ESP_INTR_FLAG_LEVEL1); if (ret != ESP_OK) { ESP_LOGE(TAG, "UART driver install failed: %s", esp_err_to_name(ret)); _uart_num = UART_NUM_MAX; // Reset state return false; } // Set UART pins ret = uart_set_pin(_uart_num, _tx_pin, _rx_pin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); if (ret != ESP_OK) { ESP_LOGE(TAG, "UART set pin failed: %s", esp_err_to_name(ret)); // Clean up driver if pin setting fails uart_driver_uninstall(_uart_num); _uart_num = UART_NUM_MAX; // Reset state return false; } ESP_LOGI(TAG, "LG290P Initialized on UART %d (TX:%d, RX:%d) at %d baud", _uart_num, _tx_pin, _rx_pin, baud_rate); // Clear ring buffer state _ringWritePos = 0; _ringReadPos = 0; _ringCount = 0; _rx_buffer_read_pos = 0; // Reset driver buffer read position tracker return true; } void SparkFun_LG290P_GNSS::stop() { if (_uart_num < UART_NUM_MAX) { ESP_LOGI(TAG, "Stopping LG290P on UART %d", _uart_num); // Uninstall the UART driver esp_err_t ret = uart_driver_uninstall(_uart_num); if (ret != ESP_OK) { ESP_LOGE(TAG, "Failed to uninstall UART driver: %s", esp_err_to_name(ret)); } _uart_num = UART_NUM_MAX; // Mark as uninitialized _rx_pin = -1; _tx_pin = -1; // Clear ring buffer state _ringWritePos = 0; _ringReadPos = 0; _ringCount = 0; } } int SparkFun_LG290P_GNSS::available() { // Check the ring buffer count first if (_ringCount > 0) { return _ringCount; } // If ring buffer is empty, try to refill it from the driver buffer _checkAndRefillRingBuffer(); // Return the current count after refill attempt return _ringCount; } int SparkFun_LG290P_GNSS::read() { // First, try to get a byte from the ring buffer int byte = _ringBufferPop(); if (byte != -1) { // Update last character time whenever we successfully read a byte _lastCharTimeMs = getMillis(); return byte; } // If ring buffer was empty, attempt to refill it _checkAndRefillRingBuffer(); // Try reading from the ring buffer again after refill byte = _ringBufferPop(); if (byte != -1) { // Update last character time _lastCharTimeMs = getMillis(); return byte; } // If still no byte after refill attempt, check timeout based on original Arduino logic // The original logic implies a timeout for reading *any* data, not just between bytes. // This implementation focuses on feeding the ring buffer, let's assume a timeout // might be handled by the caller or in readNMEA. Return -1 if buffer is truly empty. // Let's refine this: the 'read' method in Arduino often has an implicit timeout via Stream. // We can simulate this by checking available() before trying to pop. If available is 0, // we wait a short period for data to arrive and refill. if (available() == 0) { // If still nothing after refill check // Wait briefly for data to arrive - mimic Stream's potential blocking nature // Or return -1 immediately if non-blocking is desired. // Let's implement a small wait if no data is present. vTaskDelay(pdMS_TO_TICKS(5)); // Wait 5 ms _checkAndRefillRingBuffer(); // Try refilling again byte = _ringBufferPop(); if (byte != -1) { _lastCharTimeMs = getMillis(); return byte; } } // If we reach here, the buffer is empty. return -1; } int SparkFun_LG290P_GNSS::write(uint8_t data) { if (_uart_num >= UART_NUM_MAX) { ESP_LOGE(TAG, "UART not initialized."); return -1; } // Use uart_write_bytes for single byte write int written = uart_write_bytes(_uart_num, (const char*)&data, 1); // It might return 0 if the buffer is full, handle this if necessary return written; } int SparkFun_LG290P_GNSS::write(const uint8_t *buffer, size_t size) { if (_uart_num >= UART_NUM_MAX) { ESP_LOGE(TAG, "UART not initialized."); return -1; } if (buffer == NULL || size == 0) { return 0; } int written = uart_write_bytes(_uart_num, (const char*)buffer, size); return written; } void SparkFun_LG290P_GNSS::flush() { if (_uart_num >= UART_NUM_MAX) { return; } // Wait for UART TX buffer to empty and transmission to finish esp_err_t ret = uart_wait_tx_idle_nohold(_uart_num); if (ret != ESP_OK) { ESP_LOGW(TAG, "uart_wait_tx_idle_nohold returned error: %s", esp_err_to_name(ret)); } } bool SparkFun_LG290P_GNSS::readNMEA(char *sentenceBuffer, size_t bufferSize, uint32_t timeout_ms) { if (_uart_num >= UART_NUM_MAX || !sentenceBuffer || bufferSize == 0) { return false; } char *dest = sentenceBuffer; size_t bytesRead = 0; unsigned long startTime = getMillis(); bool sentenceStarted = false; // Clear buffer and reset variables memset(sentenceBuffer, 0, bufferSize); _lastCharTimeMs = getMillis(); // Reset last char time for this read operation while ((getMillis() - startTime) < timeout_ms) { int c = read(); // Use the safe read() method if (c != -1) { // Update last character time upon successful read _lastCharTimeMs = getMillis(); // Start processing once we see the '$' if (c == '$') { sentenceStarted = true; dest = sentenceBuffer; // Reset destination pointer bytesRead = 0; // Reset bytes read count } if (sentenceStarted) { if (bytesRead < bufferSize - 1) { // Leave space for null terminator *dest++ = (char)c; bytesRead++; // Check for end of sentence ('\n') if (c == '\n') { *dest = '\0'; // Null-terminate the string // Optional: Trim leading/trailing whitespace if needed return true; // Successfully read a sentence } } else { // Buffer overflow before finding newline ESP_LOGW(TAG, "NMEA sentence buffer overflow"); // We could try to recover by discarding until newline, but easier to fail return false; } } // Continue loop if we haven't started or haven't finished the sentence } else { // No character received within the loop's small delay inside read(). // Check if the timeout based on *last character received* has expired. // Note: This timeout logic is tricky. The original Arduino lib might have had // a timeout for the *entire sentence*, not just between chars. // Let's stick to the overall timeout passed to this function. // If read() returns -1, we just continue the loop until the main timeout expires. // If read() itself had a built-in delay, this wait might be redundant. vTaskDelay(pdMS_TO_TICKS(1)); // Small delay to prevent busy-waiting } } // Timeout occurred before receiving a complete sentence ESP_LOGW(TAG, "Timeout while reading NMEA sentence."); return false; } // Helper function to parse NMEA sentence components // Returns the number of items successfully parsed. // Handles empty fields. static int parse_nmea_sentence(const char *sentence, const char *start_token, const char *format, ...) { if (strncmp(sentence, start_token, strlen(start_token)) != 0) { return 0; // Does not start with the expected token } char sentence_copy[LG290P_DEFAULT_NMEA_BUFFER_SIZE]; strncpy(sentence_copy, sentence, sizeof(sentence_copy) - 1); sentence_copy[sizeof(sentence_copy) - 1] = '\0'; // Ensure null termination // Replace commas with spaces to make strtok_r work easier (optional, can parse directly) // Note: strtok_r modifies the string char *saveptr; char *token = strtok_r(sentence_copy, ","); if (!token) return 0; // Should not happen if sentence starts with token va_list args; va_start(args, format); int count = 0; int format_idx = 0; // Loop through format specifiers while (format[format_idx] != '\0' && token != NULL) { if (format[format_idx] == 's') { // String (or char) char **field = va_arg(args, char **); if (field) { // Handle potential empty field by checking if token is empty if (strlen(token) > 0) { strncpy(*field, token, strlen(token)); // Copy token to output buffer (*field)[strlen(token)] = '\0'; // Null terminate } else { strcpy(*field, ""); // Assign empty string if field is empty } count++; } } else if (format[format_idx] == 'd') { // Integer int *value = va_arg(args, int *); if (value) { if (strlen(token) > 0) { *value = atoi(token); } else { *value = 0; // Or some default invalid value? Let's use 0 for now. } count++; } } else if (format[format_idx] == 'f') { // Float/Double double *value = va_arg(args, double *); if (value) { if (strlen(token) > 0) { *value = atof(token); } else { *value = INVALID_GPS_VAL; // Use defined invalid value } count++; } } else if (format[format_idx] == 'c') { // Single Character (e.g., status 'A'/'V') char *value = va_arg(args, char *); if (value) { if (strlen(token) > 0) { *value = token[0]; } else { *value = '\0'; // Default invalid char } count++; } } // Move to the next token and format specifier token = strtok_r(NULL, ","); format_idx++; } va_end(args); return count; // Return the number of fields successfully parsed (or attempted) } // --- GGA Parsing --- bool SparkFun_LG290P_GNSS::parseGGA(const char *sentence, nmea_gga_t *ggaData) { if (!sentence || !ggaData) return false; // Example GGA: $GPGGA,142805.00,4035.7891,N,07402.5891,W,1,08,0.9,13.0,M,-34.2,M,,*4E // Format: HHMMSS.ss,ddmm.mmmm,N/S,dddmm.mmmm,E/W, Q,sat,hdop,alt,M,sep,M,,chk // Indices: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 char utc_time_str[15]; char lat_str[15]; char lon_str[15]; char lat_hemi; // N/S char lon_hemi; // E/W char fix_qual_char; // GGA fix quality char (e.g., '1') int satellites; double hdop; double altitude; char alt_units; // 'M' for meters double geoid_sep; char sep_units; // 'M' for meters // Using sscanf is often cleaner than strtok for fixed formats // %*[^,]* means skip characters until ',' (for the '$GPGGA' part) // %14[^,] matches up to 14 characters that are not ',' // %d matches integer, %f matches double // We need to handle the empty fields carefully. // Let's use a robust parsing approach with check for empty fields // Use a temporary buffer for parsing char temp_sentence[LG290P_DEFAULT_NMEA_BUFFER_SIZE]; strncpy(temp_sentence, sentence, sizeof(temp_sentence) - 1); temp_sentence[sizeof(temp_sentence)-1] = '\0'; // Directly use sscanf for simpler fields // Need to map the fields correctly int items_parsed = sscanf(temp_sentence, "$GPGGA,%14[^,],%14[^,],%c,%14[^,],%c,%1[^,],%d,%lf,%lf,%c,%lf,%c,,%*s", // Ignore checksum part utc_time_str, lat_str, &lat_hemi, lon_str, &lon_hemi, &fix_qual_char, &satellites, &hdop, &altitude, &alt_units, &geoid_sep, &sep_units); if (items_parsed < 7) { // Need at least time, lat, lon, quality, satellites, hdop, altitude ESP_LOGW(TAG, "Failed to parse required GGA fields. Items parsed: %d", items_parsed); return false; } // Convert fields ggaData->latitude = nmeaToDecimalDegrees(lat_str); if (lat_hemi == 'S') { ggaData->latitude *= -1.0; } ggaData->longitude = nmeaToDecimalDegrees(lon_str); if (lon_hemi == 'W') { ggaData->longitude *= -1.0; } ggaData->altitude = altitude; // Assuming 'M' units in sentence ggaData->fixQuality = fix_qual_char - '0'; // Convert char '0'..'9' to int 0..9 ggaData->satellites = (uint8_t)satellites; ggaData->hdop = hdop; // Basic validation for lat/lon range if (ggaData->latitude < -90.0 || ggaData->latitude > 90.0 || ggaData->longitude < -180.0 || ggaData->longitude > 180.0) { ESP_LOGW(TAG, "Parsed Latitude/Longitude out of range."); // Optionally reset to invalid values or return false ggaData->latitude = INVALID_GPS_VAL; ggaData->longitude = INVALID_GPS_VAL; } return true; } // --- RMC Parsing --- bool SparkFun_LG290P_GNSS::parseRMC(const char *sentence, nmea_rmc_t *rmcData) { if (!sentence || !rmcData) return false; // Example RMC: $GPRMC,142805.00,A,4035.7891,N,07402.5891,W,0.1,300.0,210623,,,A*73 // Format: HHMMSS.ss,Status,ddmm.mmmm,N/S,dddmm.mmmm,E/W,spd,crs,ddmmyy,,,Chk // Indices: 0 1 2 3 4 5 6 7 8 9 10 11 char utc_time_str[15]; char status; // A=Active, V=Void char lat_str[15]; char lon_str[15]; char lat_hemi; // N/S char lon_hemi; // E/W double speed_knots; double course_deg; char date_str[15]; int items_parsed = sscanf(sentence, "$GPRMC,%14[^,],%c,%14[^,],%c,%14[^,],%c,%lf,%lf,%14[^,],,,%1s", // Last %1s might capture status char at end utc_time_str, &status, lat_str, &lat_hemi, lon_str, &lon_hemi, &speed_knots, &course_deg, date_str); // RMC minimum fields: time, status, lat, lon, speed, course, date if (items_parsed < 9 && items_parsed != 11 && items_parsed != 12 ) { // Allow for empty fields at end ESP_LOGW(TAG, "Failed to parse required RMC fields. Items parsed: %d", items_parsed); return false; } if (status != 'A') { ESP_LOGW(TAG, "RMC status is Void (V)."); // Optionally set lat/lon to invalid rmcData->latitude = INVALID_GPS_VAL; rmcData->longitude = INVALID_GPS_VAL; rmcData->speedKnots = INVALID_GPS_VAL; rmcData->courseDegrees = INVALID_GPS_VAL; return false; // Or true if you want to report void status? Let's return false if no fix. } // Convert fields rmcData->latitude = nmeaToDecimalDegrees(lat_str); if (lat_hemi == 'S') { rmcData->latitude *= -1.0; } rmcData->longitude = nmeaToDecimalDegrees(lon_str); if (lon_hemi == 'W') { rmcData->longitude *= -1.0; } rmcData->speedKnots = speed_knots; rmcData->courseDegrees = course_deg; // Basic validation for lat/lon range if (ggaData->latitude < -90.0 || ggaData->latitude > 90.0 || ggaData->longitude < -180.0 || ggaData->longitude > 180.0) { ESP_LOGW(TAG, "Parsed Latitude/Longitude out of range."); rmcData->latitude = INVALID_GPS_VAL; rmcData->longitude = INVALID_GPS_VAL; } return true; } // --- NMEA Conversion Helpers --- double SparkFun_LG290P_GNSS::nmeaToDecimalDegrees(const char *nmeaLatLon) { if (!nmeaLatLon || strlen(nmeaLatLon) < 3) { // Need at least ddmm return INVALID_GPS_VAL; } char degrees_str[3]; char minutes_str[10]; // Allow for fractional part // Extract degrees part (first 2 chars) strncpy(degrees_str, nmeaLatLon, 2); degrees_str[2] = '\0'; int degrees = atoi(degrees_str); // Extract minutes part (from 3rd char onwards) strncpy(minutes_str, nmeaLatLon + 2, sizeof(minutes_str) - 1); minutes_str[sizeof(minutes_str) - 1] = '\0'; // Ensure null termination double minutes = atof(minutes_str); if (minutes < 0.0 || minutes >= 60.0) { // Basic validation for minutes part // This can happen if the input format is wrong or field is empty after '.', e.g. "4035." // Let's try atof result directly and check if it's reasonable. minutes = atof(minutes_str); // atof returns 0.0 on error or empty string if (minutes < 0.0 || minutes >= 60.0) { ESP_LOGW(TAG, "Invalid minutes value in NMEA coordinate: %s", nmeaLatLon); return INVALID_GPS_VAL; } } double decimalDegrees = (double)degrees + (minutes / 60.0); return decimalDegrees; } int SparkFun_LG290P_GNSS::nmeaTimeToSeconds(const char *nmeaTime) { if (!nmeaTime || strlen(nmeaTime) < 6) { // HHMMSS minimum return -1; } char hour_str[3]; char min_str[3]; char sec_str[3]; // Integer part of seconds strncpy(hour_str, nmeaTime, 2); hour_str[2] = '\0'; strncpy(min_str, nmeaTime + 2, 2); min_str[2] = '\0'; strncpy(sec_str, nmeaTime + 4, 2); sec_str[2] = '\0'; // Integer seconds part int hours = atoi(hour_str); int mins = atoi(min_str); int secs = atoi(sec_str); // Basic validation if (hours >= 24 || mins >= 60 || secs >= 60) { ESP_LOGW(TAG, "Invalid NMEA time value: %s", nmeaTime); return -1; } return hours * 3600 + mins * 60 + secs; } // Simplified date conversion: returns days since Jan 1, 2000 int SparkFun_LG290P_GNSS::nmeaDateToDays(const char* nmeaDate) { if (!nmeaDate || strlen(nmeaDate) < 6) { // ddmmyy return -1; } char day_str[3], mon_str[3], year_str[3]; strncpy(day_str, nmeaDate, 2); day_str[2] = '\0'; strncpy(mon_str, nmeaDate + 2, 2); mon_str[2] = '\0'; strncpy(year_str, nmeaDate + 4, 2); year_str[2] = '\0'; int day = atoi(day_str); int mon = atoi(mon_str); int year_last_two = atoi(year_str); // Basic validation if (day < 1 || day > 31 || mon < 1 || mon > 12 || year_last_two < 0 || year_last_two > 99) { ESP_LOGW(TAG, "Invalid NMEA date value: %s", nmeaDate); return -1; } // Assume year is 20xx for simplicity. A real implementation might need year handling. int year = 2000 + year_last_two; // Using a simplified calculation relative to 2000-01-01 // This is complex to do accurately without a date library. // Let's use a placeholder calculation or a known library function if available. // For demonstration, returning raw components or a rough estimate might suffice. // Rough estimate (doesn't account for leap years perfectly) int days_in_month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // Adjust for leap years (simplified) if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) { days_in_month[2] = 29; } int total_days = 0; // Days from Jan 1, 2000 to Jan 1 of the target year for (int y = 2000; y < year; ++y) { total_days += ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0)) ? 366 : 365; } // Days from Jan 1 of the target year to the start of the target month for (int m = 1; m < mon; ++m) { total_days += days_in_month[m]; } // Days within the target month total_days += day; // Adjust relative to Jan 1, 2000 (which is day 1 in this count) return total_days -1; // Since Jan 1, 2000 should be day 0 if epoch starts then. }
3. How to Integrate into ESP-IDF Project
-
Create Component: Create a new component directory in your ESP-IDF project's
componentsfolder (e.g.,components/lg290p_gnss). -
Add Files: Place the
sparkfun_lg290p_gnss.handsparkfun_lg290p_gnss.cppfiles inside this new component directory. -
Create CMakeLists.txt: Create a
CMakeLists.txtfile inside thecomponents/lg290p_gnssdirectory with the following content:idf_component_register( SRCS "sparkfun_lg290p_gnss.cpp" INCLUDE_DIRS "." REQUIRES driver freertos esp_timer log )SRCS: Specifies the source file(s).INCLUDE_DIRS: Tells CMake where to find the header file (.).REQUIRES: Lists the ESP-IDF components this component depends on.
-
Add to Project CMakeLists.txt: Add your new component to the main
CMakeLists.txtfile in the root of your ESP-IDF project:# In your main project's CMakeLists.txt # ... other components ... include(find_cmake_dirs) list(APPEND EXTRA_COMPONENT_DIRS ${CMAKE_CURRENT_LIST_DIR}/components) # Assuming components folder is sibling to main CMakeLists.txt # Or if lg290p_gnss is directly inside components/ # add_component_cmake_args(lg290p_gnss -DIESP_IDF_VERSION=v4.4) # Example if needed # Register the component (if not automatically found) register_component(lg290p_gnss) # ... rest of the main CMakeLists.txt ...Note: Modern CMake in ESP-IDF often finds components automatically if they are in the
componentsdirectory. Explicitly addingEXTRA_COMPONENT_DIRSmight be needed depending on your project structure. -
Use in
main.cormain.cpp: Include the header and use the class.#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_log.h" #include "driver/uart.h" // Include for UART definitions #include "sparkfun_lg290p_gnss.h" // Include your custom header // Define your chosen pins and UART port #define GNSS_UART_PORT UART_NUM_1 #define GNSS_RX_GPIO_NUM 22 // Example GPIO pin for GNSS RX #define GNSS_TX_GPIO_NUM 21 // Example GPIO pin for GNSS TX // Define TAG for logging static const char *TAG = "MAIN"; extern "C" void app_main(void) { ESP_LOGI(TAG, "Starting LG290P GNSS Example..."); SparkFun_LG290P_GNSS gnss; // Create an instance // Initialize the GNSS module // Use the correct UART port and GPIO pins for your hardware setup if (!gnss.begin(GNSS_UART_PORT, GNSS_RX_GPIO_NUM, GNSS_TX_GPIO_NUM)) { ESP_LOGE(TAG, "Failed to initialize GNSS module!"); return; } // Set UART to 9600 baud if not already done by begin() // gnss.begin(GNSS_UART_PORT, GNSS_RX_GPIO_NUM, GNSS_TX_GPIO_NUM, 9600); char nmea_sentence[LG290P_DEFAULT_NMEA_BUFFER_SIZE]; nmea_gga_t gga_data; nmea_rmc_t rmc_data; while (1) { // Try to read a complete NMEA sentence if (gnss.readNMEA(nmea_sentence, sizeof(nmea_sentence), 500)) { // 500ms timeout ESP_LOGI(TAG, "Received: %s", nmea_sentence); // Check sentence type and parse if (strncmp(nmea_sentence, "$GPGGA", 6) == 0) { if (gnss.parseGGA(nmea_sentence, &gga_data)) { ESP_LOGI(TAG, "Parsed GGA: Lat=%.6f, Lon=%.6f, Alt=%.1f, Sats=%d, Quality=%d", gga_data.latitude, gga_data.longitude, gga_data.altitude, gga_data.satellites, gga_data.fixQuality); } else { ESP_LOGW(TAG, "Failed to parse GGA sentence."); } } else if (strncmp(nmea_sentence, "$GPRMC", 6) == 0) { if (gnss.parseRMC(nmea_sentence, &rmc_data)) { ESP_LOGI(TAG, "Parsed RMC: Lat=%.6f, Lon=%.6f, Speed=%.1f knots, Course=%.1f deg", rmc_data.latitude, rmc_data.longitude, rmc_data.speedKnots, rmc_data.courseDegrees); } else { ESP_LOGW(TAG, "Failed to parse RMC sentence."); } } } else { // ESP_LOGD(TAG, "No complete NMEA sentence received within timeout."); } vTaskDelay(pdMS_TO_TICKS(1000)); // Wait a second before next read attempt } // Stop the module (optional, usually program runs indefinitely) // gnss.stop(); }
Key Changes and Considerations:
- UART Handling: Replaced
SoftwareSerialwith ESP-IDF's UART driver (driver/uart.h). This is more robust and efficient. Pins and UART port are now configurable. - Buffering: The
read()method now uses an internal ring buffer to mimic the byte-by-byte streaming behavior of Arduino'sStreamclass, makingreadNMEAeasier to adapt. The_checkAndRefillRingBufferhelper manages moving data from the UART driver's buffer to this ring buffer. - Timing: Replaced
millis()withesp_timer_get_time() / 1000ULL. - Logging: Replaced
Serial.printetc. with ESP IDF'sESP_LOGxmacros. - String Handling: Replaced Arduino
Stringobjects with standard C++chararrays and functions likestrncpy,sscanf,strtok_r.std::vectorcould also be used. - Parsing: Refactored parsing logic (
parseGGA,parseRMC) to usesscanffor better robustness, especially handling potentially empty fields common in NMEA sentences. Added helper functions for NMEA format conversions. - Error Handling: Added checks for
esp_err_treturn values from UART functions and usedESP_LOGEorESP_LOGWaccordingly. - Class Structure: The C++ class structure is maintained.
- Header Guard: Added standard
#ifndef/#define/#endifguards. stop()Method: Added astop()method to uninstall the UART driver and release resources, analogous to C++ destructors or Arduino cleanup.
Remember to adjust the
GNSS_UART_PORT,GNSS_RX_GPIO_NUM, andGNSS_TX_GPIO_NUMdefines in yourmain.cpp(or wherever you use the library) to match your specific hardware connections.-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.