feat(modem): Add pregenerated files to git

Author: david-cermak

.github/workflows/modem__build-host-tests.yml

@@ -100,3 +100,19 @@ jobs:
         run_executable: false
         run_coverage: false
         pre_run_script: "esp-protocols/components/esp_modem/test/host_test/env.sh"
+
+  esp_modem_generated_commands:
+    if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
+    name: Generated commands compatibility
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v4
+        shell: bash
+        run: |
+          apt-get update -y
+          apt-get install -y astyle
+          cd components/esp_modem
+          find examples/ -type f -regex '.*/generate/.*\.\(hpp\|cpp\)' -exec ./scripts/generate.sh {} \;
+          ./scripts/generate.sh
+          git diff --quiet

components/esp_modem/command/include/cxx_include/esp_modem_command_library.hpp

@@ -0,0 +1,368 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "cxx_include/esp_modem_dte.hpp"
+#include "cxx_include/esp_modem_dce_module.hpp"
+#include "cxx_include/esp_modem_types.hpp"
+
+//  --- ESP-MODEM command module starts here ---
+namespace esp_modem {
+namespace dce_commands {
+
+/**
+ * @defgroup ESP_MODEM_DCE_COMMAND ESP_MODEM DCE command library
+ * @brief Library of the most useful DCE commands
+ */
+/** @addtogroup ESP_MODEM_DCE_COMMAND
+ * @{
+ */
+
+/**
+ * @brief Generic AT command to be send with pass and fail phrases
+ *
+ * @param t Commandable object (anything that can accept commands)
+ * @param command Command to be sent do the commandable object
+ * @param pass_phrase String to be present in the reply to pass this command
+ * @param fail_phrase String to be present in the reply to fail this command
+ * @param timeout_ms Timeout in 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);
+
+/**
+ * @brief Declaration of all commands is generated from esp_modem_command_declare.inc
+ */
+
+
+//
+//#define INT_IN(name) int name
+//#ifdef __cplusplus
+//#define STRING_IN(name) const std::string& name
+//#define STRING_OUT(name) std::string& name
+//#define BOOL_IN(name) const bool name
+//#define BOOL_OUT(name) bool& name
+//#define INT_OUT(name) int& name
+//#define INTEGER_LIST_IN(name) const int* name
+//#define STRUCT_OUT(struct_name, name)  struct_name& name
+//#else
+//#define STRING_IN(name) const char* name
+//#define STRING_OUT(name) char* name
+//#define BOOL_IN(name) const bool name
+//#define BOOL_OUT(name) bool* name
+//#define INT_OUT(name) int* name
+//#define INTEGER_LIST_IN(name) const int* name
+//#define STRUCT_OUT(struct_name, name)  esp_modem_ ## struct_name ## _t* name
+//#endif
+//
+//#define FORWARD_INT_IN(name) name
+//#define FORWARD_STRING_IN(name) name
+//#define FORWARD_STRING_OUT(name) name
+//#define FORWARD_BOOL_IN(name) name
+//#define FORWARD_BOOL_OUT(name) name
+//#define FORWARD_INT_OUT(name) name
+//#define FORWARD_INTEGER_LIST_IN(name) name
+//#define FORWARD_STRUCT_OUT(struct_name, name) name
+
+// Utility to count arguments (works for up to two parameters here)
+
+
+
+/**
+ * @brief Sends the initial AT sequence to sync up with the device
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result sync(CommandableIf *t );
+
+/**
+ * @brief Reads the operator name
+ * @param[out] name operator name
+ * @param[out] act access technology
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_operator_name(CommandableIf *t, std::string &name, int &act );
+
+/**
+ * @brief Stores current user profile
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result store_profile(CommandableIf *t );
+
+/**
+ * @brief Sets the supplied PIN code
+ * @param[in] pin Pin
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_pin(CommandableIf *t, const std::string &pin );
+
+/**
+ * @brief Execute the supplied AT command in raw mode (doesn't append '\r' to command, returns everything)
+ * @param[in] cmd String command that's send to DTE
+ * @param[out] out Raw output from DTE
+ * @param[in] pass Pattern in response for the API to return OK
+ * @param[in] fail Pattern in response for the API to return FAIL
+ * @param[in] timeout AT command timeout in milliseconds
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result at_raw(CommandableIf *t, const std::string &cmd, std::string &out, const std::string &pass, const std::string &fail, int timeout );
+
+/**
+ * @brief Execute the supplied AT command
+ * @param[in] cmd AT command
+ * @param[out] out Command output string
+ * @param[in] timeout AT command timeout in milliseconds
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result at(CommandableIf *t, const std::string &cmd, std::string &out, int timeout );
+
+/**
+ * @brief Checks if the SIM needs a PIN
+ * @param[out] pin_ok true if the SIM card doesn't need a PIN to unlock
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result read_pin(CommandableIf *t, bool &pin_ok );
+
+/**
+ * @brief Sets echo mode
+ * @param[in] echo_on true if echo mode on (repeats the commands)
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_echo(CommandableIf *t, const bool echo_on );
+
+/**
+ * @brief Sets the Txt or Pdu mode for SMS (only txt is supported)
+ * @param[in] txt true if txt mode
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result sms_txt_mode(CommandableIf *t, const bool txt );
+
+/**
+ * @brief Sets the default (GSM) character set
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result sms_character_set(CommandableIf *t );
+
+/**
+ * @brief Sends SMS message in txt mode
+ * @param[in] number Phone number to send the message to
+ * @param[in] message Text message to be sent
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result send_sms(CommandableIf *t, const std::string &number, const std::string &message );
+
+/**
+ * @brief Resumes data mode (Switches back to the data mode, which was temporarily suspended)
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result resume_data_mode(CommandableIf *t );
+
+/**
+ * @brief Sets php context
+ * @param[in] p1 PdP context struct to setup modem cellular connection
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_pdp_context(CommandableIf *t, PdpContext &pdp );
+
+/**
+ * @brief Switches to the command mode
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_command_mode(CommandableIf *t );
+
+/**
+ * @brief Switches to the CMUX mode
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_cmux(CommandableIf *t );
+
+/**
+ * @brief Reads the IMSI number
+ * @param[out] imsi Module's IMSI number
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_imsi(CommandableIf *t, std::string &imsi );
+
+/**
+ * @brief Reads the IMEI number
+ * @param[out] imei Module's IMEI number
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_imei(CommandableIf *t, std::string &imei );
+
+/**
+ * @brief Reads the module name
+ * @param[out] name module name
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_module_name(CommandableIf *t, std::string &name );
+
+/**
+ * @brief Sets the modem to data mode
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_data_mode(CommandableIf *t );
+
+/**
+ * @brief Get Signal quality
+ * @param[out] rssi signal strength indication
+ * @param[out] ber channel bit error rate
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_signal_quality(CommandableIf *t, int &rssi, int &ber );
+
+/**
+ * @brief Sets HW control flow
+ * @param[in] dce_flow 0=none, 2=RTS hw flow control of DCE
+ * @param[in] dte_flow 0=none, 2=CTS hw flow control of DTE
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_flow_control(CommandableIf *t, int dce_flow, int dte_flow );
+
+/**
+ * @brief Hangs up current data call
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result hang_up(CommandableIf *t );
+
+/**
+ * @brief Get voltage levels of modem power up circuitry
+ * @param[out] voltage Current status in mV
+ * @param[out] bcs charge status (-1-Not available, 0-Not charging, 1-Charging, 2-Charging done)
+ * @param[out] bcl 1-100% battery capacity, -1-Not available
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_battery_status(CommandableIf *t, int &voltage, int &bcs, int &bcl );
+
+/**
+ * @brief Power down the module
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result power_down(CommandableIf *t );
+
+/**
+ * @brief Reset the module
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result reset(CommandableIf *t );
+
+/**
+ * @brief Configures the baudrate
+ * @param[in] baud Desired baud rate of the DTE
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_baud(CommandableIf *t, int baud );
+
+/**
+ * @brief Force an attempt to connect to a specific operator
+ * @param[in] mode mode of attempt
+ * mode=0 - automatic
+ * mode=1 - manual
+ * mode=2 - deregister
+ * mode=3 - set format for read operation
+ * mode=4 - manual with fallback to automatic
+ * @param[in] format what format the operator is given in
+ * format=0 - long format
+ * format=1 - short format
+ * format=2 - numeric
+ * @param[in] oper the operator to connect to
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_operator(CommandableIf *t, int mode, int format, const std::string &oper );
+
+/**
+ * @brief Attach or detach from the GPRS service
+ * @param[in] state 1-attach 0-detach
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_network_attachment_state(CommandableIf *t, int state );
+
+/**
+ * @brief Get network attachment state
+ * @param[out] state 1-attached 0-detached
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_network_attachment_state(CommandableIf *t, int &state );
+
+/**
+ * @brief What mode the radio should be set to
+ * @param[in] state state 1-full 0-minimum ...
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_radio_state(CommandableIf *t, int state );
+
+/**
+ * @brief Get current radio state
+ * @param[out] state 1-full 0-minimum ...
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_radio_state(CommandableIf *t, int &state );
+
+/**
+ * @brief Set network mode
+ * @param[in] mode preferred mode
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_network_mode(CommandableIf *t, int mode );
+
+/**
+ * @brief Preferred network mode (CAT-M and/or NB-IoT)
+ * @param[in] mode preferred selection
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_preferred_mode(CommandableIf *t, int mode );
+
+/**
+ * @brief Set network bands for CAT-M or NB-IoT
+ * @param[in] mode CAT-M or NB-IoT
+ * @param[in] bands bitmap in hex representing bands
+ * @param[in] size size of teh bands bitmap
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_network_bands(CommandableIf *t, const std::string &mode, const int *bands, int size );
+
+/**
+ * @brief Show network system mode
+ * @param[out] mode current network mode
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_network_system_mode(CommandableIf *t, int &mode );
+
+/**
+ * @brief GNSS power control
+ * @param[out] mode power mode (0 - off, 1 - on)
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result set_gnss_power_mode(CommandableIf *t, int mode );
+
+/**
+ * @brief GNSS power control
+ * @param[out] mode power mode (0 - off, 1 - on)
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result get_gnss_power_mode(CommandableIf *t, int &mode );
+
+
+
+/**
+ * @brief Following commands that are different for some specific modules
+ */
+command_result get_battery_status_sim7xxx(CommandableIf *t, int &voltage, int &bcs, int &bcl);
+command_result set_gnss_power_mode_sim76xx(CommandableIf *t, int mode);
+command_result power_down_sim76xx(CommandableIf *t);
+command_result power_down_sim70xx(CommandableIf *t);
+command_result set_network_bands_sim76xx(CommandableIf *t, const std::string &mode, const int *bands, int size);
+command_result power_down_sim8xx(CommandableIf *t);
+command_result set_data_mode_alt(CommandableIf *t);
+command_result set_pdp_context(CommandableIf *t, PdpContext &pdp, uint32_t timeout_ms);
+
+/**
+ * @}
+ */
+
+} // dce_commands
+} // esp_modem

components/esp_modem/command/include/cxx_include/esp_modem_dce_generic.hpp

@@ -0,0 +1,93 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "cxx_include/esp_modem_dte.hpp"
+#include "cxx_include/esp_modem_dce_module.hpp"
+#include "cxx_include/esp_modem_types.hpp"
+
+
+namespace sock_commands {
+
+//  --- ESP-MODEM command module starts here ---
+
+//
+//#define INT_IN(name) int name
+//#ifdef __cplusplus
+//#define STRING_IN(name) const std::string& name
+//#define STRING_OUT(name) std::string& name
+//#define BOOL_IN(name) const bool name
+//#define BOOL_OUT(name) bool& name
+//#define INT_OUT(name) int& name
+//#define INTEGER_LIST_IN(name) const int* name
+//#define STRUCT_OUT(struct_name, name)  struct_name& name
+//#else
+//#define STRING_IN(name) const char* name
+//#define STRING_OUT(name) char* name
+//#define BOOL_IN(name) const bool name
+//#define BOOL_OUT(name) bool* name
+//#define INT_OUT(name) int* name
+//#define INTEGER_LIST_IN(name) const int* name
+//#define STRUCT_OUT(struct_name, name)  esp_modem_ ## struct_name ## _t* name
+//#endif
+//
+//#define FORWARD_INT_IN(name) name
+//#define FORWARD_STRING_IN(name) name
+//#define FORWARD_STRING_OUT(name) name
+//#define FORWARD_BOOL_IN(name) name
+//#define FORWARD_BOOL_OUT(name) name
+//#define FORWARD_INT_OUT(name) name
+//#define FORWARD_INTEGER_LIST_IN(name) name
+//#define FORWARD_STRUCT_OUT(struct_name, name) name
+
+// Utility to count arguments (works for up to two parameters here)
+
+
+
+/**
+ * @brief Opens network in AT command mode
+ * @return OK, FAIL or TIMEOUT
+ */
+esp_modem::command_result net_open(esp_modem::CommandableIf *t );
+
+/**
+ * @brief Closes network in AT command mode
+ * @return OK, FAIL or TIMEOUT
+ */
+esp_modem::command_result net_close(esp_modem::CommandableIf *t );
+
+/**
+ * @brief Opens a TCP connection
+ * @param[in] host Host name or IP address to connect to
+ * @param[in] port Port number
+ * @param[in] timeout Connection timeout
+ * @return OK, FAIL or TIMEOUT
+ */
+esp_modem::command_result tcp_open(esp_modem::CommandableIf *t, const std::string &host, int port, int timeout );
+
+/**
+ * @brief Closes opened TCP socket
+ * @return OK, FAIL or TIMEOUT
+ */
+esp_modem::command_result tcp_close(esp_modem::CommandableIf *t );
+
+/**
+ * @brief Gets modem IP address
+ * @param[out] addr String representation of modem's IP
+ * @return OK, FAIL or TIMEOUT
+ */
+esp_modem::command_result get_ip(esp_modem::CommandableIf *t, std::string &addr );
+
+/**
+ * @brief Sets Rx mode
+ * @param[in] mode 0=auto, 1=manual
+ * @return OK, FAIL or TIMEOUT
+ */
+esp_modem::command_result set_rx_mode(esp_modem::CommandableIf *t, int mode );
+
+
+}

components/esp_modem/command/include/cxx_include/esp_modem_dce_module.hpp

@@ -0,0 +1,296 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "esp_modem_config.h"
+#include "cxx_include/esp_modem_api.hpp"
+#include <cxx_include/esp_modem_dce_factory.hpp>
+#include "sock_commands.hpp"
+#include <sys/socket.h>
+
+#pragma  once
+
+namespace sock_dce {
+
+
+enum class status {
+    IDLE,
+    CONNECTING,
+    SENDING,
+    RECEIVING,
+    FAILED,
+    PENDING
+};
+
+class Responder {
+public:
+    enum class ret {
+        OK, FAIL, IN_PROGRESS, NEED_MORE_DATA, NEED_MORE_TIME
+    };
+    Responder(int &s, int &ready_fd, std::shared_ptr<esp_modem::DTE> &dte_arg):
+        sock(s), data_ready_fd(ready_fd), dte(dte_arg) {}
+    ret process_data(status state, uint8_t *data, size_t len);
+    ret check_async_replies(status state, std::string_view &response);
+
+    void start_sending(size_t len);
+    void start_receiving(size_t len);
+    bool start_connecting(std::string host, int port);
+    status pending();
+    uint8_t *get_buf()
+    {
+        return &buffer[0];
+    }
+    size_t get_buf_len()
+    {
+        return buffer_size;
+    }
+
+    void clear_offsets()
+    {
+        actual_read = 0;
+    }
+
+    size_t data_available()
+    {
+        return actual_read;
+    }
+
+    size_t has_data()
+    {
+        return total_len;
+    }
+
+private:
+    static constexpr size_t buffer_size = 512;
+
+    bool on_read(char *data, size_t len)
+    {
+#ifndef CONFIG_EXAMPLE_CUSTOM_TCP_TRANSPORT
+        ::send(sock, data, len, 0);
+#else
+        ::memcpy(&buffer[actual_read], data, len);
+        actual_read += len;
+#endif
+        return true;
+    }
+
+    ret recv(uint8_t *data, size_t len);
+    ret send(uint8_t *data, size_t len);
+    ret send(std::string_view response);
+    ret connect(std::string_view response);
+    void send_cmd(std::string_view command)
+    {
+        dte->write((uint8_t *) command.begin(), command.size());
+    }
+    std::array<uint8_t, buffer_size> buffer;
+    size_t data_to_recv = 0;
+    size_t actual_read = 0;
+    size_t total_len = 0;
+
+    bool read_again = false;
+    int &sock;
+    int &data_ready_fd;
+    int send_stat = 0;
+    size_t data_to_send = 0;
+    std::shared_ptr<esp_modem::DTE> &dte;
+};
+
+class DCE : public ::esp_modem::GenericModule {
+    using esp_modem::GenericModule::GenericModule;
+public:
+
+//  --- ESP-MODEM command module starts here ---
+
+//
+//#define INT_IN(name) int name
+//#ifdef __cplusplus
+//#define STRING_IN(name) const std::string& name
+//#define STRING_OUT(name) std::string& name
+//#define BOOL_IN(name) const bool name
+//#define BOOL_OUT(name) bool& name
+//#define INT_OUT(name) int& name
+//#define INTEGER_LIST_IN(name) const int* name
+//#define STRUCT_OUT(struct_name, name)  struct_name& name
+//#else
+//#define STRING_IN(name) const char* name
+//#define STRING_OUT(name) char* name
+//#define BOOL_IN(name) const bool name
+//#define BOOL_OUT(name) bool* name
+//#define INT_OUT(name) int* name
+//#define INTEGER_LIST_IN(name) const int* name
+//#define STRUCT_OUT(struct_name, name)  esp_modem_ ## struct_name ## _t* name
+//#endif
+//
+//#define FORWARD_INT_IN(name) name
+//#define FORWARD_STRING_IN(name) name
+//#define FORWARD_STRING_OUT(name) name
+//#define FORWARD_BOOL_IN(name) name
+//#define FORWARD_BOOL_OUT(name) name
+//#define FORWARD_INT_OUT(name) name
+//#define FORWARD_INTEGER_LIST_IN(name) name
+//#define FORWARD_STRUCT_OUT(struct_name, name) name
+
+// Utility to count arguments (works for up to two parameters here)
+
+
+
+    /**
+     * @brief Opens network in AT command mode
+     * @return OK, FAIL or TIMEOUT
+     */
+    esp_modem::command_result net_open();
+
+    /**
+     * @brief Closes network in AT command mode
+     * @return OK, FAIL or TIMEOUT
+     */
+    esp_modem::command_result net_close();
+
+    /**
+     * @brief Opens a TCP connection
+     * @param[in] host Host name or IP address to connect to
+     * @param[in] port Port number
+     * @param[in] timeout Connection timeout
+     * @return OK, FAIL or TIMEOUT
+     */
+    esp_modem::command_result tcp_open(const std::string &host, int port, int timeout );
+
+    /**
+     * @brief Closes opened TCP socket
+     * @return OK, FAIL or TIMEOUT
+     */
+    esp_modem::command_result tcp_close();
+
+    /**
+     * @brief Gets modem IP address
+     * @param[out] addr String representation of modem's IP
+     * @return OK, FAIL or TIMEOUT
+     */
+    esp_modem::command_result get_ip(std::string &addr );
+
+    /**
+     * @brief Sets Rx mode
+     * @param[in] mode 0=auto, 1=manual
+     * @return OK, FAIL or TIMEOUT
+     */
+    esp_modem::command_result set_rx_mode(int mode );
+
+
+    bool init();
+    bool connect(std::string host, int port);
+
+    void start_listening(int port);
+
+    bool perform_sock();
+
+    void set_idle()
+    {
+        signal.set(IDLE);
+    }
+
+    bool wait_to_idle(uint32_t ms)
+    {
+        if (!signal.wait(IDLE, ms)) {
+            ESP_LOGE("dce", "Failed to get idle");
+            return false;
+        }
+        if (state != status::IDLE) {
+            ESP_LOGE("dce", "Unexpected state %d", static_cast<int>(state));
+            return false;
+        }
+        return true;
+    }
+
+    int sync_recv(char *buffer, int len, int timeout_ms)
+    {
+        if (!wait_to_idle(timeout_ms)) {
+            return 0;
+        }
+        at.clear_offsets();
+        state = status::RECEIVING;
+        uint64_t data;
+        read(data_ready_fd, &data, sizeof(data));
+        int max_len = std::min(len, (int)at.get_buf_len());
+        at.start_receiving(max_len);
+        if (!signal.wait(IDLE, 500 + timeout_ms)) {
+            return 0;
+        }
+        int ret = at.data_available();
+        if (ret > 0) {
+            memcpy(buffer, at.get_buf(), ret);
+        }
+        set_idle();
+        return ret;
+    }
+
+    int sync_send(const char *buffer, size_t len, int timeout_ms)
+    {
+        int len_to_send = std::min(len, at.get_buf_len());
+        if (!wait_to_idle(timeout_ms)) {
+            return -1;
+        }
+        state = status::SENDING;
+        memcpy(at.get_buf(), buffer, len_to_send);
+        ESP_LOG_BUFFER_HEXDUMP("dce", at.get_buf(), len, ESP_LOG_VERBOSE);
+        at.start_sending(len_to_send);
+        if (!signal.wait(IDLE, timeout_ms + 1000)) {
+            if (state == status::PENDING) {
+                state = status::IDLE;
+            } else {
+                return -1;
+            }
+        }
+        set_idle();
+        return len_to_send;
+    }
+
+    int wait_to_read(uint32_t ms)
+    {
+        if (at.has_data() > 0) {
+            ESP_LOGD("dce", "Data buffered in modem (len=%d)", at.has_data());
+            return 1;
+        }
+        struct timeval tv = {
+            .tv_sec = static_cast<time_t>(ms / 1000),
+            .tv_usec = 0,
+        };
+        fd_set fdset;
+        FD_ZERO(&fdset);
+        FD_SET(data_ready_fd, &fdset);
+        int s = select(data_ready_fd + 1, &fdset, nullptr, nullptr, &tv);
+        if (s == 0) {
+            return 0;
+        } else if (s < 0) {
+            ESP_LOGE("dce", "select error %d", errno);
+            return -1;
+        }
+        if (FD_ISSET(data_ready_fd, &fdset)) {
+            ESP_LOGD("dce", "select read: modem data available");
+            return 1;
+        }
+        return -1;
+    }
+
+private:
+    esp_modem::SignalGroup signal;
+
+    void close_sock();
+    bool accept_sock();
+    bool sock_to_at();
+    bool at_to_sock();
+
+    void perform_at(uint8_t *data, size_t len);
+
+    status state{status::IDLE};
+    static constexpr uint8_t IDLE = 1;
+    Responder at{sock, data_ready_fd, dte};
+    int sock {-1};
+    int listen_sock {-1};
+    int data_ready_fd {-1};
+};
+
+std::unique_ptr<DCE> create(const esp_modem::dce_config *config, std::shared_ptr<esp_modem::DTE> dte);
+
+}

components/esp_modem/command/src/esp_modem_modules.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */

components/esp_modem/examples/modem_console/main/command/my_module_dce.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */

components/esp_modem/examples/modem_console/main/command/my_module_dce.hpp

@@ -52,4 +52,5 @@ for file in "${files[@]}"; do
   # Preprocess everything else to expand command prototypes or implementations
   sed -n '1,/ESP-MODEM command module starts here/!p' "$in_file" | \
   $compiler -I"$script_dir" -I"$processing_dir/generate/include" -I"$processing_dir/include" -I"$current_file_dir" -  >> "$out_file"
+  astyle --style=otbs --attach-namespaces --attach-classes --indent=spaces=4 --convert-tabs --align-pointer=name --align-reference=name --keep-one-line-statements --pad-header --pad-oper --quiet "$out_file"
 done