From 652314e73d72f72b982d0b63d1f6748585c7bc91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Franz=20H=C3=B6pfinger?= Date: Tue, 23 Aug 2022 14:13:10 +0200 Subject: [PATCH] fix(esp_modem) Add example that reads GNSS info --- .../components/SIM7070_gnss/CMakeLists.txt | 9 + .../components/SIM7070_gnss/SIM7070_gnss.cpp | 340 ++++++++++++++++++ .../components/SIM7070_gnss/SIM7070_gnss.hpp | 57 +++ .../components/SIM7070_gnss/nmea_parser.h | 137 +++++++ .../simple_cmux_client/main/Kconfig.projbuild | 4 + .../main/simple_cmux_client_main.cpp | 56 ++- .../simple_cmux_client/sdkconfig.defaults | 2 +- .../include/cxx_include/command_library.hpp | 27 ++ .../src/esp_modem_command_library.cpp | 14 +- 9 files changed, 634 insertions(+), 12 deletions(-) create mode 100644 components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/CMakeLists.txt create mode 100644 components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.cpp create mode 100644 components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.hpp create mode 100644 components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/nmea_parser.h create mode 100644 components/esp_modem/include/cxx_include/command_library.hpp diff --git a/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/CMakeLists.txt b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/CMakeLists.txt new file mode 100644 index 000000000..86e1fa24a --- /dev/null +++ b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/CMakeLists.txt @@ -0,0 +1,9 @@ +idf_component_register(SRCS "SIM7070_gnss.cpp" + INCLUDE_DIRS "." + PRIV_REQUIRES esp_modem) + +set_target_properties(${COMPONENT_LIB} PROPERTIES + CXX_STANDARD 17 + CXX_STANDARD_REQUIRED ON + CXX_EXTENSIONS ON +) diff --git a/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.cpp b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.cpp new file mode 100644 index 000000000..cafe1c2bb --- /dev/null +++ b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.cpp @@ -0,0 +1,340 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// +// Created on: 23.08.2022 +// Author: franz + + +#include +#include +#include +#include +#include +#include +#include +#include "sdkconfig.h" +#include "esp_event.h" +#include "cxx_include/esp_modem_dte.hpp" +#include "cxx_include/esp_modem_dce.hpp" +#include "esp_modem_config.h" +#include "cxx_include/esp_modem_api.hpp" +#include "cxx_include/command_library.hpp" +#include "esp_log.h" +#include "SIM7070_gnss.hpp" + + +const static char *const TAG = "SIM7070_gnss"; + + +class LocalFactory: public esp_modem::dce_factory::Factory { +public: + static std::unique_ptr create(const esp_modem::dce_config *config, std::shared_ptr dte, esp_netif_t *netif) + { + return esp_modem::dce_factory::Factory::build_generic_DCE>(config, dte, netif); + } + +}; +/** + * @brief Helper create method which employs the DCE factory for creating DCE objects templated by a custom module + * @return unique pointer of the resultant DCE + */ +std::unique_ptr create_SIM7070_GNSS_dce(const esp_modem::dce_config *config, + std::shared_ptr dte, + esp_netif_t *netif) +{ + return LocalFactory::create(config, std::move(dte), netif); +} + +esp_modem::command_result get_gnss_information_sim70xx_lib(esp_modem::CommandableIf *t, gps_t &gps) +{ + + ESP_LOGV(TAG, "%s", __func__ ); + std::string_view out; + auto ret = esp_modem::dce_commands::generic_get_string(t, "AT+CGNSINF\r", out); + if (ret != esp_modem::command_result::OK) { + return ret; + } + + + + constexpr std::string_view pattern = "+CGNSINF: "; + if (out.find(pattern) == std::string_view::npos) { + return esp_modem::command_result::FAIL; + } + /** + * Parsing +CGNSINF: + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * , + * + */ + out = out.substr(pattern.size()); + int pos = 0; + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //GNSS run status + int GNSS_run_status; + if (std::from_chars(out.data(), out.data() + pos, GNSS_run_status).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + gps.run = (gps_run_t)GNSS_run_status; + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //Fix status + { + std::string_view fix_status = out.substr(0, pos); + if (fix_status.length() > 1) { + int Fix_status; + if (std::from_chars(out.data(), out.data() + pos, Fix_status).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + gps.fix = (gps_fix_t)Fix_status; + } else { + gps.fix = GPS_FIX_INVALID; + } + } //clean up Fix status + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //UTC date & Time + { + std::string_view UTC_date_and_Time = out.substr(0, pos); + if (UTC_date_and_Time.length() > 1) { + if (std::from_chars(out.data() + 0, out.data() + 4, gps.date.year).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + if (std::from_chars(out.data() + 4, out.data() + 6, gps.date.month).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + if (std::from_chars(out.data() + 6, out.data() + 8, gps.date.day).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + if (std::from_chars(out.data() + 8, out.data() + 10, gps.tim.hour).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + if (std::from_chars(out.data() + 10, out.data() + 12, gps.tim.minute).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + if (std::from_chars(out.data() + 12, out.data() + 14, gps.tim.second).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + if (std::from_chars(out.data() + 15, out.data() + 18, gps.tim.thousand).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + } else { + gps.date.year = 0; + gps.date.month = 0; + gps.date.day = 0; + gps.tim.hour = 0; + gps.tim.minute = 0; + gps.tim.second = 0; + gps.tim.thousand = 0; + } + + } //clean up UTC date & Time + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //Latitude + { + std::string_view Latitude = out.substr(0, pos); + if (Latitude.length() > 1) { + gps.latitude = std::stof(std::string(out.substr(0, pos))); + } else { + gps.latitude = 0; + } + } //clean up Latitude + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //Longitude + { + std::string_view Longitude = out.substr(0, pos); + if (Longitude.length() > 1) { + gps.longitude = std::stof(std::string(out.substr(0, pos))); + } else { + gps.longitude = 0; + } + } //clean up Longitude + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //Altitude + { + std::string_view Altitude = out.substr(0, pos); + if (Altitude.length() > 1) { + gps.altitude = std::stof(std::string(out.substr(0, pos))); + } else { + gps.altitude = 0; + } + } //clean up Altitude + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //Speed Over Ground Km/hour + { + std::string_view gps_speed = out.substr(0, pos); + if (gps_speed.length() > 1) { + gps.speed = std::stof(std::string(gps_speed)); + } else { + gps.speed = 0; + } + } //clean up gps_speed + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //Course Over Ground degrees + { + std::string_view gps_cog = out.substr(0, pos); + if (gps_cog.length() > 1) { + gps.cog = std::stof(std::string(gps_cog)); + } else { + gps.cog = 0; + } + } //clean up gps_cog + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + // Fix Mode + { + std::string_view FixModesubstr = out.substr(0, pos); + if (FixModesubstr.length() > 1) { + int Fix_Mode; + if (std::from_chars(out.data(), out.data() + pos, Fix_Mode).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + gps.fix_mode = (gps_fix_mode_t)Fix_Mode; + } else { + gps.fix_mode = GPS_MODE_INVALID; + } + } //clean up Fix Mode + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //HDOP + { + std::string_view HDOP = out.substr(0, pos); + if (HDOP.length() > 1) { + gps.dop_h = std::stof(std::string(HDOP)); + } else { + gps.dop_h = 0; + } + } //clean up HDOP + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //PDOP + { + std::string_view PDOP = out.substr(0, pos); + if (PDOP.length() > 1) { + gps.dop_p = std::stof(std::string(PDOP)); + } else { + gps.dop_p = 0; + } + } //clean up PDOP + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //VDOP + { + std::string_view VDOP = out.substr(0, pos); + if (VDOP.length() > 1) { + gps.dop_v = std::stof(std::string(VDOP)); + } else { + gps.dop_v = 0; + } + } //clean up VDOP + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //sats_in_view + { + std::string_view sats_in_view = out.substr(0, pos); + if (sats_in_view.length() > 1) { + if (std::from_chars(out.data(), out.data() + pos, gps.sats_in_view).ec == std::errc::invalid_argument) { + return esp_modem::command_result::FAIL; + } + } else { + gps.sats_in_view = 0; + } + } //clean up sats_in_view + + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + out = out.substr(pos + 1); + if ((pos = out.find(',')) == std::string::npos) { + return esp_modem::command_result::FAIL; + } + //HPA + { + std::string_view HPA = out.substr(0, pos); + if (HPA.length() > 1) { + gps.hpa = std::stof(std::string(HPA)); + } else { + gps.hpa = 0; + } + } //clean up HPA + out = out.substr(pos + 1); + //VPA + { + std::string_view VPA = out.substr(0, pos); + if (VPA.length() > 1) { + gps.vpa = std::stof(std::string(VPA)); + } else { + gps.vpa = 0; + } + } //clean up VPA + + return esp_modem::command_result::OK; +} + +esp_modem::command_result SIM7070_gnss::get_gnss_information_sim70xx(gps_t &gps) +{ + return get_gnss_information_sim70xx_lib(dte.get(), gps); +} + +esp_modem::command_result DCE_gnss::get_gnss_information_sim70xx(gps_t &gps) +{ + return device->get_gnss_information_sim70xx(gps); +} diff --git a/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.hpp b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.hpp new file mode 100644 index 000000000..10650867e --- /dev/null +++ b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.hpp @@ -0,0 +1,57 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// +// Created on: 23.08.2022 +// Author: franz + + +#pragma once + + +#include "cxx_include/esp_modem_dce_factory.hpp" +#include "cxx_include/esp_modem_dce_module.hpp" +#include "nmea_parser.h" + +/** + * @brief Definition of a custom modem which inherits from the GenericModule, uses all its methods + * and could override any of them. Here, for demonstration purposes only, we redefine just `get_module_name()` + */ +class SIM7070_gnss: public esp_modem::SIM7070 { + using SIM7070::SIM7070; +public: + esp_modem::command_result get_gnss_information_sim70xx(gps_t &gps); +}; + +class DCE_gnss : public esp_modem::DCE_T { +public: + + using DCE_T::DCE_T; +#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, num, ...) \ + template \ + esp_modem::return_type name(Agrs&&... args) \ + { \ + return device->name(std::forward(args)...); \ + } + + DECLARE_ALL_COMMAND_APIS(forwards name(...) + { + device->name(...); + } ) + +#undef ESP_MODEM_DECLARE_DCE_COMMAND + + esp_modem::command_result get_gnss_information_sim70xx(gps_t &gps); + +}; + + +/** + * @brief Helper create method which employs the DCE factory for creating DCE objects templated by a custom module + * @return unique pointer of the resultant DCE + */ +std::unique_ptr create_SIM7070_GNSS_dce(const esp_modem::dce_config *config, + std::shared_ptr dte, + esp_netif_t *netif); diff --git a/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/nmea_parser.h b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/nmea_parser.h new file mode 100644 index 000000000..4f6fcebf9 --- /dev/null +++ b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/nmea_parser.h @@ -0,0 +1,137 @@ +/* + * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + * + * Origin: https://github.com/espressif/esp-idf/blob/master/examples/peripherals/uart/nmea0183_parser/main/nmea_parser.h + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GPS_MAX_SATELLITES_IN_USE (12) +#define GPS_MAX_SATELLITES_IN_VIEW (16) + + + +/** + * @brief GPS fix type + * + */ +typedef enum { + GPS_FIX_INVALID, /*!< Not fixed */ + GPS_FIX_GPS, /*!< GPS */ + GPS_FIX_DGPS, /*!< Differential GPS */ +} gps_fix_t; + +/** + * @brief GPS run type + * + */ +typedef enum { + GPS_RUN_INVALID, /*!< Not fixed */ + GPS_RUN_GPS, /*!< GPS */ +} gps_run_t; + +/** + * @brief GPS fix mode + * + */ +typedef enum { + GPS_MODE_INVALID, /*!< Not fixed */ + GPS_MODE_2D, /*!< 2D GPS */ + GPS_MODE_3D /*!< 3D GPS */ +} gps_fix_mode_t; + +/** + * @brief GPS satellite information + * + */ +typedef struct { + uint8_t num; /*!< Satellite number */ + uint8_t elevation; /*!< Satellite elevation */ + uint16_t azimuth; /*!< Satellite azimuth */ + uint8_t snr; /*!< Satellite signal noise ratio */ +} gps_satellite_t; + +/** + * @brief GPS time + * + */ +typedef struct { + uint8_t hour; /*!< Hour */ + uint8_t minute; /*!< Minute */ + uint8_t second; /*!< Second */ + uint16_t thousand; /*!< Thousand */ +} gps_time_t; + +/** + * @brief GPS date + * + */ +typedef struct { + uint8_t day; /*!< Day (start from 1) */ + uint8_t month; /*!< Month (start from 1) */ + uint16_t year; /*!< Year (start from 2000) */ +} gps_date_t; + +/** + * @brief NMEA Statement + * + */ +typedef enum { + STATEMENT_UNKNOWN = 0, /*!< Unknown statement */ + STATEMENT_GGA, /*!< GGA */ + STATEMENT_GSA, /*!< GSA */ + STATEMENT_RMC, /*!< RMC */ + STATEMENT_GSV, /*!< GSV */ + STATEMENT_GLL, /*!< GLL */ + STATEMENT_VTG /*!< VTG */ +} nmea_statement_t; + +/** + * @brief GPS object + * + */ +struct gps_s { + float latitude; /*!< Latitude (degrees) */ + float longitude; /*!< Longitude (degrees) */ + float altitude; /*!< Altitude (meters) */ + gps_run_t run; /*!< run status */ + gps_fix_t fix; /*!< Fix status */ + uint8_t sats_in_use; /*!< Number of satellites in use */ + gps_time_t tim; /*!< time in UTC */ + gps_fix_mode_t fix_mode; /*!< Fix mode */ + float dop_h; /*!< Horizontal dilution of precision */ + float dop_p; /*!< Position dilution of precision */ + float dop_v; /*!< Vertical dilution of precision */ + uint8_t sats_in_view; /*!< Number of satellites in view */ + gps_date_t date; /*!< Fix date */ + float speed; /*!< Ground speed, unit: m/s */ + float cog; /*!< Course over ground */ + float hpa; /*!< Horizontal Position Accuracy */ + float vpa; /*!< Vertical Position Accuracy */ +}; + +typedef struct gps_s gps_t; +typedef struct gps_s esp_modem_gps_s_t; + + + + +/** + * @brief NMEA Parser Event ID + * + */ +typedef enum { + GPS_UPDATE, /*!< GPS information has been updated */ + GPS_UNKNOWN /*!< Unknown statements detected */ +} nmea_event_id_t; + +#ifdef __cplusplus +} +#endif diff --git a/components/esp_modem/examples/simple_cmux_client/main/Kconfig.projbuild b/components/esp_modem/examples/simple_cmux_client/main/Kconfig.projbuild index 7c6d91752..bf733a9ee 100644 --- a/components/esp_modem/examples/simple_cmux_client/main/Kconfig.projbuild +++ b/components/esp_modem/examples/simple_cmux_client/main/Kconfig.projbuild @@ -22,6 +22,10 @@ menu "Example Configuration" bool "SIM7070" help SIM7070 is Multi-Band CAT M and NB IoT module. + config EXAMPLE_MODEM_DEVICE_SIM7070_GNSS + bool "SIM7070_GNSS" + help + SIM7070 is Multi-Band CAT M and NB IoT module with Support for GNSS Location API config EXAMPLE_MODEM_DEVICE_SIM7600 bool "SIM7600" help diff --git a/components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp b/components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp index d54fdeb03..dadbcc6cc 100644 --- a/components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp +++ b/components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp @@ -25,6 +25,7 @@ #include "esp_vfs_dev.h" // For optional VFS support #include "esp_https_ota.h" // For potential OTA configuration #include "vfs_resource/vfs_create.hpp" +#include "SIM7070_gnss.hpp" #if defined(CONFIG_EXAMPLE_FLOW_CONTROL_NONE) #define EXAMPLE_FLOW_CONTROL ESP_MODEM_FLOW_CONTROL_NONE @@ -87,15 +88,17 @@ extern "C" void app_main(void) assert(esp_netif); #if CONFIG_EXAMPLE_MODEM_DEVICE_BG96 == 1 - std::unique_ptr dce = create_BG96_dce(&dce_config, dte, esp_netif); + auto dce = create_BG96_dce(&dce_config, dte, esp_netif); #elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM800 == 1 - std::unique_ptr dce = create_SIM800_dce(&dce_config, dte, esp_netif); + auto dce = create_SIM800_dce(&dce_config, dte, esp_netif); #elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7000 == 1 - std::unique_ptr dce = create_SIM7000_dce(&dce_config, dte, esp_netif); + auto dce = create_SIM7000_dce(&dce_config, dte, esp_netif); #elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7070 == 1 - std::unique_ptr dce = create_SIM7070_dce(&dce_config, dte, esp_netif); + auto dce = create_SIM7070_dce(&dce_config, dte, esp_netif); +#elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7070_GNSS == 1 + auto dce = create_SIM7070_GNSS_dce(&dce_config, dte, esp_netif); #elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7600 == 1 - std::unique_ptr dce = create_SIM7600_dce(&dce_config, dte, esp_netif); + auto dce = create_SIM7600_dce(&dce_config, dte, esp_netif); #else #error "Unsupported device" #endif @@ -135,6 +138,12 @@ extern "C" void app_main(void) } std::cout << "Operator name:" << str << std::endl; +#if CONFIG_EXAMPLE_MODEM_DEVICE_SIM7070_GNSS == 1 + if (dce->set_gnss_power_mode(1) == esp_modem::command_result::OK) { + std::cout << "Modem set_gnss_power_mode: OK" << std::endl; + } +#endif + /* Try to connect to the network and publish an mqtt topic */ ESPEventHandlerSync event_handler(loop); event_handler.listen_to(ESPEvent(IP_EVENT, ESPEventID(ESP_EVENT_ANY_ID))); @@ -184,6 +193,43 @@ extern "C" void app_main(void) std::cout << "Modem IMSI number:" << str << std::endl; } + +#if CONFIG_EXAMPLE_MODEM_DEVICE_SIM7070_GNSS == 1 + gps_t gps; + + for (int i = 0; i < 200; ++i) { + if (dce->get_gnss_information_sim70xx(gps) == esp_modem::command_result::OK) { + ESP_LOGI(TAG, "gps.run %i", + gps.run); + ESP_LOGI(TAG, "gps.fix %i", + gps.fix); + ESP_LOGI(TAG, "gps.date.year %i gps.date.month %i gps.date.day %i", + gps.date.year, gps.date.month, gps.date.day); + ESP_LOGI(TAG, "gps.tim.hour %i gps.tim.minute %i gps.tim.second %i gps.tim.thousand %i", + gps.tim.hour, gps.tim.minute, gps.tim.second, gps.tim.thousand); + ESP_LOGI(TAG, "gps.latitude %f gps.longitude %f ", + gps.latitude, gps.longitude ); + ESP_LOGI(TAG, "gps.altitude %f", + gps.altitude); + ESP_LOGI(TAG, "gps.speed %f", + gps.speed); + ESP_LOGI(TAG, "gps.cog %f", + gps.cog); + ESP_LOGI(TAG, "gps.fix_mode %i", + gps.fix_mode); + ESP_LOGI(TAG, "gps.dop_h %f gps.dop_p %f gps.dop_v %f ", + gps.dop_h, gps.dop_p, gps.dop_v ); + ESP_LOGI(TAG, "gps.sats_in_view %i", + gps.sats_in_view); + ESP_LOGI(TAG, "gps.hpa %f gps.vpa %f", + gps.hpa, gps.vpa); + } + vTaskDelay(pdMS_TO_TICKS(1000)); //Wait + + } +#endif // CONFIG_EXAMPLE_MODEM_DEVICE_SIM7070_GNSS + + #if CONFIG_EXAMPLE_PERFORM_OTA == 1 esp_http_client_config_t config = { }; config.skip_cert_common_name_check = true; diff --git a/components/esp_modem/examples/simple_cmux_client/sdkconfig.defaults b/components/esp_modem/examples/simple_cmux_client/sdkconfig.defaults index 8f54fe475..dab94ca82 100644 --- a/components/esp_modem/examples/simple_cmux_client/sdkconfig.defaults +++ b/components/esp_modem/examples/simple_cmux_client/sdkconfig.defaults @@ -9,4 +9,4 @@ CONFIG_PARTITION_TABLE_TWO_OTA=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF=y CONFIG_NEWLIB_STDIN_LINE_ENDING_LF=y -CONFIG_MAIN_TASK_STACK_SIZE=8192 +CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192 diff --git a/components/esp_modem/include/cxx_include/command_library.hpp b/components/esp_modem/include/cxx_include/command_library.hpp new file mode 100644 index 000000000..c2c00ee69 --- /dev/null +++ b/components/esp_modem/include/cxx_include/command_library.hpp @@ -0,0 +1,27 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once +namespace esp_modem::dce_commands { +command_result generic_command(CommandableIf *t, const std::string &command, + const std::list &pass_phrase, + const std::list &fail_phrase, + uint32_t timeout_ms); + + +command_result generic_command(CommandableIf *t, const std::string &command, + const std::string &pass_phrase, + const std::string &fail_phrase, uint32_t timeout_ms); + +command_result generic_get_string(CommandableIf *t, const std::string &command, std::string_view &output, uint32_t timeout_ms = 500); + +command_result generic_get_string(CommandableIf *t, const std::string &command, std::string &output, uint32_t timeout_ms = 500); + +command_result generic_command_common(CommandableIf *t, const std::string &command, uint32_t timeout = 500); + + + +} // esp_modem::dce_commands diff --git a/components/esp_modem/src/esp_modem_command_library.cpp b/components/esp_modem/src/esp_modem_command_library.cpp index 18d74532f..5b320a054 100644 --- a/components/esp_modem/src/esp_modem_command_library.cpp +++ b/components/esp_modem/src/esp_modem_command_library.cpp @@ -10,6 +10,8 @@ #include "cxx_include/esp_modem_dte.hpp" #include "cxx_include/esp_modem_dce_module.hpp" #include "cxx_include/esp_modem_command_library.hpp" +#include "cxx_include/command_library.hpp" + namespace esp_modem::dce_commands { @@ -40,9 +42,9 @@ command_result generic_command(CommandableIf *t, const std::string &command, } -static inline command_result generic_command(CommandableIf *t, const std::string &command, - const std::string &pass_phrase, - const std::string &fail_phrase, uint32_t timeout_ms) +command_result generic_command(CommandableIf *t, const std::string &command, + const std::string &pass_phrase, + const std::string &fail_phrase, uint32_t timeout_ms) { ESP_LOGV(TAG, "%s", __func__ ); const auto pass = std::list({pass_phrase}); @@ -50,7 +52,7 @@ static inline command_result generic_command(CommandableIf *t, const std::string return generic_command(t, command, pass, fail, timeout_ms); } -static inline command_result generic_get_string(CommandableIf *t, const std::string &command, std::string_view &output, uint32_t timeout_ms = 500) +command_result generic_get_string(CommandableIf *t, const std::string &command, std::string_view &output, uint32_t timeout_ms) { ESP_LOGV(TAG, "%s", __func__ ); return t->command(command, [&](uint8_t *data, size_t len) { @@ -77,7 +79,7 @@ static inline command_result generic_get_string(CommandableIf *t, const std::str }, timeout_ms); } -static inline command_result generic_get_string(CommandableIf *t, const std::string &command, std::string &output, uint32_t timeout_ms = 500) +command_result generic_get_string(CommandableIf *t, const std::string &command, std::string &output, uint32_t timeout_ms) { ESP_LOGV(TAG, "%s", __func__ ); std::string_view out; @@ -89,7 +91,7 @@ static inline command_result generic_get_string(CommandableIf *t, const std::str } -static inline command_result generic_command_common(CommandableIf *t, const std::string &command, uint32_t timeout = 500) +command_result generic_command_common(CommandableIf *t, const std::string &command, uint32_t timeout) { ESP_LOGV(TAG, "%s", __func__ ); return generic_command(t, command, "OK", "ERROR", timeout);