esp_modem: Allow error handler register in C

C++ API offers interface to register error callback.
C API isn't flexible enough, so we offer conversion function between C++ and C enums.

components/esp_modem/include/esp_modem_c_api_types.h

@@ -60,6 +60,23 @@ typedef enum esp_modem_dce_device
     ESP_MODEM_DCE_SIM800,
 } esp_modem_dce_device_t;
 
+/**
+ * @brief Terminal errors
+ */
+typedef enum esp_modem_terminal_error
+{
+    ESP_MODEM_TERMINAL_BUFFER_OVERFLOW,
+    ESP_MODEM_TERMINAL_CHECKSUM_ERROR,
+    ESP_MODEM_TERMINAL_UNEXPECTED_CONTROL_FLOW,
+    ESP_MODEM_TERMINAL_DEVICE_GONE,
+    ESP_MODEM_TERMINAL_UNKNOWN_ERROR,
+} esp_modem_terminal_error_t;
+
+/**
+ * @brief Terminal error callback
+ */
+typedef void (*esp_modem_terminal_error_cbt)(esp_modem_terminal_error_t);
+
 /**
  * @brief Create a generic DCE handle for new modem API
  *
@@ -90,6 +107,15 @@ esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, const esp_mode
  */
 void esp_modem_destroy(esp_modem_dce_t * dce);
 
+/**
+ * @brief Set DTE's error callback
+ * 
+ * @param dce Modem DCE handle
+ * @param[in] err_cb Error callback
+ * @return ESP_OK on success, ESP_FAIL on failure
+ */
+esp_err_t esp_modem_set_error_cb(esp_modem_dce_t * dce, esp_modem_terminal_error_cbt err_cb);
+
 /**
  * @brief Set operation mode for this DCE
  * @param dce Modem DCE handle

components/esp_modem/include/esp_private/c_api_wrapper.hpp

@@ -12,6 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+/**
+ * @file c_api_wrapper.hpp
+ * @brief Collection of C API wrappers
+ * 
+ * This file is located in include/esp_private because it is not intended for users,
+ * but rather for esp_modem C extension developers.
+ * 
+ * The C extension API must provide a 'factory function' that returns initialized pointer to esp_modem_dce_wrap.
+ * Helper functions provided below, can be used for conversion between C++ enum classes and standard C enums.
+ */
+
 #pragma once
 
 #include "cxx_include/esp_modem_dce_factory.hpp"
@@ -23,6 +34,8 @@ struct esp_modem_dce_wrap { // need to mimic the polymorphic dispatch as CPP use
     enum class modem_wrap_dte_type { UART, VFS, USB } dte_type;
     dce_factory::ModemType modem_type;
     DCE *dce;
+    std::shared_ptr<DTE> dte;
+    esp_modem_dce_wrap() : dce(nullptr), dte(nullptr) {}
 };
 
 inline dce_factory::ModemType convert_modem_enum(esp_modem_dce_device_t module)
@@ -43,3 +56,32 @@ inline dce_factory::ModemType convert_modem_enum(esp_modem_dce_device_t module)
         return esp_modem::dce_factory::ModemType::GenericModule;
     }
 }
+
+inline esp_modem_terminal_error_t convert_terminal_error_enum(terminal_error err)
+{
+    switch (err) {
+    case terminal_error::BUFFER_OVERFLOW:
+        return ESP_MODEM_TERMINAL_BUFFER_OVERFLOW;
+    case terminal_error::CHECKSUM_ERROR:
+        return ESP_MODEM_TERMINAL_CHECKSUM_ERROR;
+    case terminal_error::UNEXPECTED_CONTROL_FLOW:
+        return ESP_MODEM_TERMINAL_UNEXPECTED_CONTROL_FLOW;
+    case terminal_error::DEVICE_GONE:
+        return ESP_MODEM_TERMINAL_DEVICE_GONE;
+    default:
+        return ESP_MODEM_TERMINAL_UNKNOWN_ERROR;
+    }
+}
+
+inline esp_err_t command_response_to_esp_err(command_result res)
+{
+    switch (res) {
+    case command_result::OK:
+        return ESP_OK;
+    case command_result::FAIL:
+        return ESP_FAIL;
+    case command_result::TIMEOUT:
+        return ESP_ERR_TIMEOUT;
+    }
+    return ESP_ERR_INVALID_ARG;
+}

components/esp_modem/src/esp_modem_c_api.cpp

@@ -36,19 +36,6 @@ size_t strlcpy(char *dest, const char *src, size_t len);
 // C API definitions
 using namespace esp_modem;
 
-static inline esp_err_t command_response_to_esp_err(command_result res)
-{
-    switch (res) {
-    case command_result::OK:
-        return ESP_OK;
-    case command_result::FAIL:
-        return ESP_FAIL;
-    case command_result::TIMEOUT:
-        return ESP_ERR_TIMEOUT;
-    }
-    return ESP_ERR_INVALID_ARG;
-}
-
 extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
 {
     auto dce_wrap = new (std::nothrow) esp_modem_dce_wrap;
@@ -60,6 +47,7 @@ extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, con
         delete dce_wrap;
         return nullptr;
     }
+    dce_wrap->dte = dte;
     dce_factory::Factory f(convert_modem_enum(module));
     dce_wrap->dce = f.build(dce_config, std::move(dte), netif);
     if (dce_wrap->dce == nullptr) {
@@ -84,6 +72,22 @@ extern "C" void esp_modem_destroy(esp_modem_dce_t *dce_wrap)
     }
 }
 
+extern "C" esp_err_t esp_modem_set_error_cb(esp_modem_dce_t * dce_wrap, esp_modem_terminal_error_cbt err_cb)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || dce_wrap->dte == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (err_cb) {
+        dce_wrap->dte->set_error_cb([err_cb](terminal_error err) {
+            err_cb(convert_terminal_error_enum(err));
+        });
+    } else {
+        dce_wrap->dte->set_error_cb(nullptr);
+    }
+    return ESP_OK;
+}
+
 extern "C" esp_err_t esp_modem_sync(esp_modem_dce_t *dce_wrap)
 {
     if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {