Merge pull request #30 from Sjurinho/feature/extended-simcom-support

Feature/extended simcom support (IDFGH-7243)

components/esp_modem/src/esp_modem_api.cpp

@@ -54,6 +54,16 @@ std::unique_ptr<DCE> create_SIM7600_dce(const dce_config *config, std::shared_pt
     return create_modem_dce(dce_factory::ModemType::SIM7600, config, std::move(dte), netif);
 }
 
+std::unique_ptr<DCE> create_SIM7070_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif)
+{
+    return create_modem_dce(dce_factory::ModemType::SIM7070, config, std::move(dte), netif);
+}
+
+std::unique_ptr<DCE> create_SIM7000_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif)
+{
+    return create_modem_dce(dce_factory::ModemType::SIM7000, config, std::move(dte), netif);
+}
+
 std::unique_ptr<DCE> create_SIM800_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif)
 {
     return create_modem_dce(dce_factory::ModemType::SIM800, config, std::move(dte), netif);

components/esp_modem/src/esp_modem_c_api.cpp

@@ -59,6 +59,10 @@ static inline dce_factory::ModemType convert_modem_enum(esp_modem_dce_device_t m
     switch (module) {
     case ESP_MODEM_DCE_SIM7600:
         return esp_modem::dce_factory::ModemType::SIM7600;
+    case ESP_MODEM_DCE_SIM7070:
+        return esp_modem::dce_factory::ModemType::SIM7070;
+    case ESP_MODEM_DCE_SIM7000:
+        return esp_modem::dce_factory::ModemType::SIM7000;
     case ESP_MODEM_DCE_BG96:
         return esp_modem::dce_factory::ModemType::BG96;
     case ESP_MODEM_DCE_SIM800:
@@ -271,3 +275,100 @@ extern "C" esp_err_t esp_modem_power_down(esp_modem_dce_t *dce_wrap)
     }
     return command_response_to_esp_err(dce_wrap->dce->power_down());
 }
+
+extern "C" esp_err_t esp_modem_set_operator(esp_modem_dce_t *dce_wrap, int mode, int format, const char* oper)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string operator_str(oper);
+    return command_response_to_esp_err(dce_wrap->dce->set_operator(mode, format, operator_str));
+}
+
+extern "C" esp_err_t esp_modem_set_network_attachment_state(esp_modem_dce_t *dce_wrap, int state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_network_attachment_state(state));
+}
+
+extern "C" esp_err_t esp_modem_get_network_attachment_state(esp_modem_dce_t *dce_wrap, int *p_state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int state;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_attachment_state(state));
+    if (ret == ESP_OK) {
+        *p_state = state;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_radio_state(esp_modem_dce_t *dce_wrap, int state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_radio_state(state));
+}
+
+extern "C" esp_err_t esp_modem_get_radio_state(esp_modem_dce_t *dce_wrap, int *p_state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int state;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_radio_state(state));
+    if (ret == ESP_OK) {
+        *p_state = state;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_network_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_network_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_set_preferred_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_preferred_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_set_network_bands(esp_modem_dce_t *dce_wrap, const char* mode, const int* bands, int size)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string mode_str(mode);
+    return command_response_to_esp_err(dce_wrap->dce->set_network_bands(mode, bands, size));
+}
+
+extern "C" esp_err_t esp_modem_get_network_system_mode(esp_modem_dce_t *dce_wrap, int* p_mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int mode;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_system_mode(mode));
+    if (ret == ESP_OK) {
+        *p_mode = mode;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_gnss_power_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_gnss_power_mode(mode));
+}

components/esp_modem/src/esp_modem_command_library.cpp

@@ -121,12 +121,18 @@ command_result power_down(CommandableIf *t)
     return generic_command(t, "AT+QPOWD=1\r", "POWERED DOWN", "ERROR", 1000);
 }
 
-command_result power_down_sim7xxx(CommandableIf *t)
+command_result power_down_sim76xx(CommandableIf *t)
 {
     ESP_LOGV(TAG, "%s", __func__ );
     return generic_command_common(t, "AT+CPOF\r", 1000);
 }
 
+command_result power_down_sim70xx(CommandableIf *t)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command(t, "AT+CPOWD=1\r", "POWER DOWN", "ERROR", 1000);
+}
+
 command_result power_down_sim8xx(CommandableIf *t)
 {
     ESP_LOGV(TAG, "%s", __func__ );
@@ -399,4 +405,142 @@ command_result get_signal_quality(CommandableIf *t, int &rssi, int &ber)
     return command_result::OK;
 }
 
+command_result set_operator(CommandableIf *t, int mode, int format, const std::string& oper)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command_common(t, "AT+COPS=" + std::to_string(mode) + "," + std::to_string(format) + ",\"" + oper + "\"\r", 90000);
+}
+
+command_result set_network_attachment_state(CommandableIf *t, int state)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command_common(t, "AT+CGATT=" + std::to_string(state) + "\r");
+}
+
+command_result get_network_attachment_state(CommandableIf *t, int &state)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string_view out;
+    auto ret = generic_get_string(t, "AT+CGATT?\r", out);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    constexpr std::string_view pattern = "+CGATT: ";
+    constexpr int pos = pattern.size();
+    if (out.find(pattern) == std::string::npos) {
+        return command_result::FAIL;
+    }
+
+    if (std::from_chars(out.data() + pos, out.data() + out.size(), state).ec == std::errc::invalid_argument) {
+        return command_result::FAIL;
+    }
+
+    return command_result::OK;
+}
+
+command_result set_radio_state(CommandableIf *t, int state)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command_common(t, "AT+CFUN=" + std::to_string(state) + "\r");
+}
+
+command_result get_radio_state(CommandableIf *t, int &state)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string_view out;
+    auto ret = generic_get_string(t, "AT+CFUN?\r", out);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    constexpr std::string_view pattern = "+CFUN: ";
+    constexpr int pos = pattern.size();
+    if (out.find(pattern) == std::string::npos) {
+        return command_result::FAIL;
+    }
+
+    if (std::from_chars(out.data() + pos, out.data() + out.size(), state).ec == std::errc::invalid_argument) {
+        return command_result::FAIL;
+    }
+
+    return command_result::OK;
+}
+
+command_result set_network_mode(CommandableIf *t, int mode)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command_common(t, "AT+CNMP=" + std::to_string(mode) + "\r");
+}
+
+command_result set_preferred_mode(CommandableIf *t, int mode)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command_common(t, "AT+CMNB=" + std::to_string(mode) + "\r");
+}
+
+command_result set_network_bands(CommandableIf *t, const std::string& mode, const int* bands, int size)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string band_string = "";
+    for (int i = 0; i<size-1; ++i){
+        band_string += std::to_string(bands[i]) + ",";
+    }
+    band_string += std::to_string(bands[size-1]);
+    
+    return generic_command_common(t, "AT+CBANDCFG=\"" + mode + "\"," + band_string + "\r");
+}
+
+// mode is expected to be 64bit string (in hex)
+// any_mode = "0xFFFFFFFF7FFFFFFF";
+command_result set_network_bands_sim76xx(CommandableIf *t, const std::string& mode, const int* bands, int size)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    static const char *hexDigits = "0123456789ABCDEF";
+    uint64_t band_bits = 0;
+    int hex_len = 16;
+    std::string band_string(hex_len, '0');
+    for (int i = 0; i<size; ++i) {
+        // OR-operation to add bands
+        auto band = bands[i]-1; // Sim7600 has 0-indexed band selection (band 20 has to be shifted 19 places)
+        band_bits |= 1 << band;
+    }
+    for(int i=hex_len; i>0; i--){
+        band_string[i-1] = hexDigits[(band_bits >> ((hex_len-i)*4)) & 0xF];
+    }
+    return generic_command_common(t, "AT+CNBP=" + mode + ",0x" + band_string + "\r");
+}
+
+command_result get_network_system_mode(CommandableIf *t, int &mode)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string_view out;
+    auto ret = generic_get_string(t, "AT+CNSMOD?\r", out);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+
+    constexpr std::string_view pattern = "+CNSMOD: ";
+    int mode_pos = out.find(",") + 1; // Skip "<n>,"
+    if (out.find(pattern) == std::string::npos) {
+        return command_result::FAIL;
+    }
+
+    if (std::from_chars(out.data() + mode_pos, out.data() + out.size(), mode).ec == std::errc::invalid_argument) {
+        return command_result::FAIL;
+    }
+
+    return command_result::OK;
+}
+
+command_result set_gnss_power_mode(CommandableIf *t, int mode)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command_common(t, "AT+CGNSPWR=" + std::to_string(mode) + "\r");
+}
+
+command_result set_gnss_power_mode_sim76xx(CommandableIf *t, int mode)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return generic_command_common(t, "AT+CGPS=" + std::to_string(mode) + "\r");
+}
+
 } // esp_modem::dce_commands

components/esp_modem/src/esp_modem_modules.cpp

@@ -55,9 +55,29 @@ command_result SIM7600::get_battery_status(int &voltage, int &bcs, int &bcl)
     return dce_commands::get_battery_status_sim7xxx(dte.get(), voltage, bcs, bcl);
 }
 
+command_result SIM7600::set_network_bands(const std::string& mode, const int* bands, int size)
+{
+    return dce_commands::set_network_bands_sim76xx(dte.get(), mode, bands, size);
+}
+
+command_result SIM7600::set_gnss_power_mode(int mode)
+{
+    return dce_commands::set_gnss_power_mode_sim76xx(dte.get(), mode);
+}
+
 command_result SIM7600::power_down()
 {
-    return dce_commands::power_down_sim7xxx(dte.get());
+    return dce_commands::power_down_sim76xx(dte.get());
+}
+
+command_result SIM7070::power_down()
+{
+    return dce_commands::power_down_sim70xx(dte.get());
+}
+
+command_result SIM7000::power_down()
+{
+    return dce_commands::power_down_sim70xx(dte.get());
 }
 
 command_result SIM800::power_down()