espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-17 12:32:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

update per design review

Browse Source
This commit is contained in:
David Cermak
2021-03-24 21:06:27 +01:00
parent a93cb68078
commit 8314e163fa
12 changed files with 228 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
esp_modem/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(srcs "src/esp_modem_dte.cpp" set(srcs "src/esp_modem_dte.cpp"
"src/esp_modem_dce.cpp"
"src/esp_modem_netif.cpp" "src/esp_modem_netif.cpp"
"src/esp_modem_api.cpp" "src/esp_modem_api.cpp"
"src/esp_modem_factory.cpp" "src/esp_modem_factory.cpp"

10
esp_modem/examples/modem_console/main/console_helper.cpp
View File

@ -33,6 +33,9 @@ void ConsoleCommand::RegisterCommand(const char* command, const char* help, std:
case INT1: case INT1:
common_arg = arg_int1(it.shortopts, it.longopts, it.datatype, it.glossary); common_arg = arg_int1(it.shortopts, it.longopts, it.datatype, it.glossary);
break; break;
case LIT0:
common_arg = arg_lit0(it.shortopts, it.longopts, it.glossary);
break;
} }
if (common_arg) { if (common_arg) {
arg_table.emplace_back(common_arg); arg_table.emplace_back(common_arg);
@ -67,6 +70,13 @@ std::string ConsoleCommand::get_string(int index)
return std::string(); return std::string();
} }
int ConsoleCommand::get_int(int index)
{
if (get_count(index) > 0) {
return *((struct arg_int *)arg_table[index])->ival;
}
return -1;
}
std::vector<ConsoleCommand*> ConsoleCommand::console_commands; std::vector<ConsoleCommand*> ConsoleCommand::console_commands;

8
esp_modem/examples/modem_console/main/console_helper.hpp
View File

@ -19,12 +19,16 @@ enum arg_type {
STR1, STR1,
INT0, INT0,
INT1, INT1,
LIT0,
ARG_END, ARG_END,
}; };
struct CommandArgs { struct CommandArgs {
CommandArgs(arg_type t, const char * shopts, const char * lopts, const char * data, const char * glos): CommandArgs(arg_type t, const char * shopts, const char * lopts, const char * data, const char * glos):
type(t), shortopts(shopts), longopts(lopts), datatype(data), glossary(glos) {} type(t), shortopts(shopts), longopts(lopts), datatype(data), glossary(glos) {}
CommandArgs(arg_type t, const char * shopts, const char * lopts, const char * glos):
type(t), shortopts(shopts), longopts(lopts), datatype(nullptr), glossary(glos) {}
arg_type type; arg_type type;
const char *shortopts; const char *shortopts;
const char *longopts; const char *longopts;
@ -48,8 +52,10 @@ public:
int get_count(int index); int get_count(int index);
template<typename T> int get_count_of(CommandArgs T::*member) { return get_count(index_arg(member)); } template<typename T> int get_count_of(CommandArgs T::*member) { return get_count(index_arg(member)); }
template<typename T> std::string get_string_of(CommandArgs T::*member) { return get_string(index_arg(member)); } template<typename T> std::string get_string_of(CommandArgs T::*member) { return get_string(index_arg(member)); }
template<typename T> int get_int_of(CommandArgs T::*member) { return get_int(index_arg(member)); }
std::string get_string(int index); std::string get_string(int index);
int get_int(int index);
private: private:
void RegisterCommand(const char* command, const char* help, std::vector<CommandArgs>& args); void RegisterCommand(const char* command, const char* help, std::vector<CommandArgs>& args);

35
esp_modem/examples/modem_console/main/modem_console_main.cpp
View File

@ -323,6 +323,15 @@ static esp_console_repl_t *s_repl = NULL;
// return (char*)&((T*)nullptr->*member) - (char*)nullptr; // return (char*)&((T*)nullptr->*member) - (char*)nullptr;
//} //}
#define CHECK_ERR(cmd, success_action) do { \
auto err = cmd; \
if (err == command_result::OK) { \
success_action; \
return 0; \
} else { \
ESP_LOGE(TAG, "Failed with %s", err == command_result::TIMEOUT ? "TIMEOUT":"ERROR"); \
return 1; \
} } while (0)
extern "C" void app_main(void) extern "C" void app_main(void)
{ {
@ -395,6 +404,7 @@ extern "C" void app_main(void)
} }
return 0; return 0;
}); });
std::vector<CommandArgs> no_args; std::vector<CommandArgs> no_args;
ConsoleCommand ReadPinArgs("read_pin", "checks if SIM is unlocked", no_args, [&](ConsoleCommand *c){ ConsoleCommand ReadPinArgs("read_pin", "checks if SIM is unlocked", no_args, [&](ConsoleCommand *c){
bool pin_ok; bool pin_ok;
@ -409,10 +419,35 @@ extern "C" void app_main(void)
return 0; return 0;
}); });
ConsoleCommand GetModuleName("get_module_name", "reads the module name", no_args, [&](ConsoleCommand *c){
std::string module_name;
ESP_LOGI(TAG, "Reading module name...");
CHECK_ERR(dce->get_module_name(module_name), ESP_LOGI(TAG, "OK. Module name: %s", module_name.c_str()));
});
const struct GenericCommandArgs {
GenericCommandArgs():
cmd(STR1, nullptr, nullptr, "<command>", "AT command to send to the modem"),
timeout(INT1, "t", "timeout", "<timeout>", "command timeout"),
pattern(STR0, "p", "pattern", "<pattern>", "command response to wait for"),
no_cr(LIT0, "n", "no-cr", "not add trailing CR to the command") {}
CommandArgs cmd;
CommandArgs timeout;
CommandArgs pattern;
CommandArgs no_cr;
} send_cmd_args;
ConsoleCommand SendCommand("cmd", "sends generic AT command, no_args", &send_cmd_args, sizeof(send_cmd_args), [&](ConsoleCommand *c){
auto cmd = c->get_string_of(&GenericCommandArgs::cmd);
auto timeout = c->get_int_of(&GenericCommandArgs::timeout);
ESP_LOGI(TAG, "Sending command %s with timeout %d", cmd.c_str(), timeout);
CHECK_ERR(dce->command(cmd, nullptr, timeout),
ESP_LOGI(TAG, "OK"));
});
// start console REPL // start console REPL
ESP_ERROR_CHECK(esp_console_start_repl(s_repl)); ESP_ERROR_CHECK(esp_console_start_repl(s_repl));
ESP_LOGE(TAG, "Exit console!!!"); ESP_LOGE(TAG, "Exit console!!!");
ESP_LOGE(TAG, "Cannot allocate memory (line: %d, free heap: %d bytes)", __LINE__, esp_get_free_heap_size());
while(1) { while(1) {
vTaskDelay(pdMS_TO_TICKS(50000)); vTaskDelay(pdMS_TO_TICKS(50000));
ESP_LOGI(TAG, "working!"); ESP_LOGI(TAG, "working!");

6
esp_modem/include/cxx_include/esp_modem_api.hpp
View File

@ -18,8 +18,8 @@ std::shared_ptr<DTE> create_uart_dte(const esp_modem_dte_config *config);
std::shared_ptr<GenericModule> create_generic_module(const std::shared_ptr<DTE>& dte, std::string &apn); std::shared_ptr<GenericModule> create_generic_module(const std::shared_ptr<DTE>& dte, std::string &apn);
std::shared_ptr<SIM7600> create_SIM7600_module(const std::shared_ptr<DTE>& dte, std::string &apn); std::shared_ptr<SIM7600> create_SIM7600_module(const std::shared_ptr<DTE>& dte, std::string &apn);
std::unique_ptr<DCE<GenericModule>> create_generic_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<GenericModule>& dev, esp_netif_t *netif); std::unique_ptr<DCE> create_generic_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<GenericModule>& dev, esp_netif_t *netif);
std::unique_ptr<DCE<SIM7600>> create_SIM7600_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<SIM7600>& dev, esp_netif_t *netif); std::unique_ptr<DCE> create_SIM7600_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<SIM7600>& dev, esp_netif_t *netif);
std::unique_ptr<DCE<SIM7600>> create_SIM7600_dce(const std::shared_ptr<DTE>& dte, esp_netif_t *netif, std::string &apn); std::unique_ptr<DCE> create_SIM7600_dce(const std::shared_ptr<DTE>& dte, esp_netif_t *netif, std::string &apn);

95
esp_modem/include/cxx_include/esp_modem_dce.hpp
View File

@ -1,65 +1,72 @@
#pragma once #pragma once
#include <utility>
#include "cxx_include/esp_modem_netif.hpp" #include "cxx_include/esp_modem_netif.hpp"
#include "cxx_include/esp_modem_dce_module.hpp"
#include "generate/esp_modem_command_declare.inc" #include "generate/esp_modem_command_declare.inc"
namespace esp_modem::DCE {
class Modes {
public:
Modes(): mode(modem_mode::COMMAND_MODE) {}
~Modes() = default;
bool set(DTE *dte, ModuleIf *module, PPP &netif, modem_mode m);
modem_mode get();
private:
modem_mode mode;
};
}
template<class SpecificModule> template<class SpecificModule>
class DCE { class DCE_T {
static_assert(std::is_base_of<ModuleIf, SpecificModule>::value, "DCE must be instantiated with Module class only"); static_assert(std::is_base_of<ModuleIf, SpecificModule>::value, "DCE must be instantiated with Module class only");
public: public:
explicit DCE(const std::shared_ptr<DTE>& dte, std::shared_ptr<SpecificModule> device, esp_netif_t * netif): explicit DCE_T(const std::shared_ptr<DTE>& dte, std::shared_ptr<SpecificModule> device, esp_netif_t * netif):
dce_dte(dte), device(std::move(device)), ppp_netif(dte, netif) dte(dte), module(std::move(device)), netif(dte, netif)
{ } { }
void set_data() {
device->setup_data_mode(); ~DCE_T() = default;
device->set_mode(modem_mode::DATA_MODE);
dce_dte->set_mode(modem_mode::DATA_MODE); void set_data() { set_mode(modem_mode::DATA_MODE); }
ppp_netif.start();
} void exit_data() { set_mode(modem_mode::COMMAND_MODE); }
void exit_data() {
ppp_netif.stop(); void set_cmux() { set_mode(modem_mode::CMUX_MODE); }
device->set_mode(modem_mode::COMMAND_MODE);
// uint8_t* data;
dce_dte->set_data_cb([&](size_t len) -> bool { command_result command(const std::string& command, got_line_cb got_line, uint32_t time_ms)
// auto actual_len = dce_dte->read(&data, 64); {
// ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data", data, actual_len, ESP_LOG_INFO); return dte->command(command, std::move(got_line), time_ms);
return false;
});
ppp_netif.wait_until_ppp_exits();
dce_dte->set_data_cb(nullptr);
dce_dte->set_mode(modem_mode::COMMAND_MODE);
} }
protected:
bool set_mode(modem_mode m) { return mode.set(dte.get(), module.get(), netif, m); }
std::shared_ptr<DTE> dte;
std::shared_ptr<SpecificModule> module;
PPP netif;
esp_modem::DCE::Modes mode;
};
class DCE: public DCE_T<GenericModule> {
public:
using DCE_T<GenericModule>::DCE_T;
#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, TEMPLATE_ARG, MUX_ARG, ...) \ #define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, TEMPLATE_ARG, MUX_ARG, ...) \
template <typename ...Agrs> \ template <typename ...Agrs> \
return_type name(Agrs&&... args) \ return_type name(Agrs&&... args) \
{ \ { \
return device->name(std::forward<Agrs>(args)...); \ return module->name(std::forward<Agrs>(args)...); \
} }
DECLARE_ALL_COMMAND_APIS(forwards name(...) { device->name(...); } ) DECLARE_ALL_COMMAND_APIS(forwards name(...) { device->name(...); } )
#undef ESP_MODEM_DECLARE_DCE_COMMAND #undef ESP_MODEM_DECLARE_DCE_COMMAND
// template <typename ...Params>
// command_result get_module_name(Params&&... params)
// {
// return device->get_module_name(std::forward<Params>(params)...);
// }
// template <typename ...Params>
// command_result set_data_mode(Params&&... params)
// {
// return device->set_data_mode(std::forward<Params>(params)...);
// }
command_result command(const std::string& command, got_line_cb got_line, uint32_t time_ms) {
return dce_dte->command(command, got_line, time_ms);
}
void set_cmux() { device->set_mode(modem_mode::CMUX_MODE);
dce_dte->set_mode(modem_mode::CMUX_MODE); }
private:
std::shared_ptr<DTE> dce_dte;
std::shared_ptr<SpecificModule> device;
PPP ppp_netif;
}; };

11
esp_modem/include/cxx_include/esp_modem_dce_module.hpp
View File

@ -38,10 +38,9 @@ public:
#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, TEMPLATE_ARG, MUX_ARG, ...) \ #define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, TEMPLATE_ARG, MUX_ARG, ...) \
template <typename ...Agrs> \ virtual return_type name(__VA_ARGS__);
return_type name(Agrs&&... args) { return esp_modem::dce_commands::name(dte.get(), std::forward<Agrs>(args)...); }
DECLARE_ALL_COMMAND_APIS(return_type name(...); ) DECLARE_ALL_COMMAND_APIS(virtual return_type name(...); )
#undef ESP_MODEM_DECLARE_DCE_COMMAND #undef ESP_MODEM_DECLARE_DCE_COMMAND
@ -55,16 +54,16 @@ protected:
class SIM7600: public GenericModule { class SIM7600: public GenericModule {
using GenericModule::GenericModule; using GenericModule::GenericModule;
public: public:
command_result get_module_name(std::string& name); // command_result get_module_name(std::string& name) override;
}; };
class SIM800: public GenericModule { class SIM800: public GenericModule {
using GenericModule::GenericModule; using GenericModule::GenericModule;
public: public:
command_result get_module_name(std::string& name); command_result get_module_name(std::string& name) override;
}; };
class BG96: public GenericModule { class BG96: public GenericModule {
public: public:
command_result get_module_name(std::string& name); command_result get_module_name(std::string& name) override;
}; };

42
esp_modem/include/generate/esp_modem_command_declare.inc
View File

@ -7,19 +7,19 @@
#ifdef __cplusplus #ifdef __cplusplus
#include <string> #include <string>
#define STRING_IN const std::string& string_in #define STRING_IN(x) const std::string& x
#define STRING_OUT std::string& string_out #define STRING_OUT(x) std::string& x
#define BOOL_IN const bool bool_in #define BOOL_IN(x) const bool x
#define BOOL_OUT bool& bool_out #define BOOL_OUT(x) bool& x
#define STRUCT_OUT(struct_name) struct_name& struct_out #define STRUCT_OUT(struct_name, x) struct_name& x
#else #else
struct PdpContext; struct PdpContext;
#define STRING_IN const char* string_in #define STRING_IN(x) const char* x
#define STRING_OUT char* string_out #define STRING_OUT(x) char* x
#define BOOL_IN const bool bool_in #define BOOL_IN(x) const bool x
#define BOOL_OUT bool* bool_out #define BOOL_OUT(x) bool* x
#define STRUCT_OUT(struct_name) struct struct_name* struct_out #define STRUCT_OUT(struct_name, x) struct struct_name* x
#endif #endif
@ -33,40 +33,40 @@ struct PdpContext;
* @param pin Pin * @param pin Pin
*/ \ */ \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(set_pin, command_result, TEMPLATE_ARG, MUX_ARG, STRING_IN) \ ESP_MODEM_DECLARE_DCE_COMMAND(set_pin, command_result, 1, MUX_ARG, STRING_IN(x)) \
/** /**
* @brief Checks if the SIM needs a PIN * @brief Checks if the SIM needs a PIN
* *
* @param[out] pin_ok Pin * @param[out] pin_ok Pin
*/ \ */ \
ESP_MODEM_DECLARE_DCE_COMMAND(read_pin, command_result, TEMPLATE_ARG, MUX_ARG, BOOL_OUT) \ ESP_MODEM_DECLARE_DCE_COMMAND(read_pin, command_result, 1, MUX_ARG, BOOL_OUT(x)) \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(set_echo, command_result, TEMPLATE_ARG, MUX_ARG, BOOL_IN) \ ESP_MODEM_DECLARE_DCE_COMMAND(set_echo, command_result, 1, MUX_ARG, BOOL_IN(x)) \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(resume_data_mode, command_result, TEMPLATE_ARG, MUX_ARG) \ ESP_MODEM_DECLARE_DCE_COMMAND(resume_data_mode, command_result, 0, MUX_ARG) \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(set_pdp_context, command_result, TEMPLATE_ARG, MUX_ARG, STRUCT_OUT(PdpContext)) \ ESP_MODEM_DECLARE_DCE_COMMAND(set_pdp_context, command_result, 1, MUX_ARG, STRUCT_OUT(PdpContext, x)) \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(set_command_mode, command_result, TEMPLATE_ARG, MUX_ARG) \ ESP_MODEM_DECLARE_DCE_COMMAND(set_command_mode, command_result, 0, MUX_ARG) \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(set_cmux, command_result, TEMPLATE_ARG, MUX_ARG) \ ESP_MODEM_DECLARE_DCE_COMMAND(set_cmux, command_result, 0, MUX_ARG) \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(get_imsi, command_result, TEMPLATE_ARG, MUX_ARG, STRING_OUT) \ ESP_MODEM_DECLARE_DCE_COMMAND(get_imsi, command_result, 1, MUX_ARG, STRING_OUT(x)) \
\ \
ESP_MODEM_DECLARE_DCE_COMMAND(get_imei, command_result, TEMPLATE_ARG, MUX_ARG, STRING_OUT) \ ESP_MODEM_DECLARE_DCE_COMMAND(get_imei, command_result, 1, MUX_ARG, STRING_OUT(x)) \
\ \
/** /**
* @brief Reads the module name * @brief Reads the module name
* *
* @param[out] module name * @param[out] module name
*/ \ */ \
ESP_MODEM_DECLARE_DCE_COMMAND(get_module_name, command_result, TEMPLATE_ARG, MUX_ARG, STRING_OUT) \ ESP_MODEM_DECLARE_DCE_COMMAND(get_module_name, command_result, 1, MUX_ARG, STRING_OUT(x)) \
\ \
/** /**
* @brief Sets the modem to data mode * @brief Sets the modem to data mode
* *
*/ \ */ \
ESP_MODEM_DECLARE_DCE_COMMAND(set_data_mode, command_result, TEMPLATE_ARG, MUX_ARG) ESP_MODEM_DECLARE_DCE_COMMAND(set_data_mode, command_result, 0, MUX_ARG)
// --- DCE command documentation starts here --- // --- DCE command documentation starts here ---
#ifdef GENERATE_DOCS #ifdef GENERATE_DOCS

28
esp_modem/src/esp_modem_api.cpp
View File

@ -22,29 +22,31 @@ std::shared_ptr<DTE> create_uart_dte(const esp_modem_dte_config *config)
} }
template<typename SpecificModule> template<typename SpecificModule>
std::unique_ptr<DCE<SpecificModule>> create_dce(const std::shared_ptr<DTE>& dte, const std::shared_ptr<SpecificModule>& dev, esp_netif_t *netif) std::unique_ptr<DCE_T<SpecificModule>> create_dce(const std::shared_ptr<DTE>& dte, const std::shared_ptr<SpecificModule>& dev, esp_netif_t *netif)
{ {
TRY_CATCH_RET_NULL( TRY_CATCH_RET_NULL(
return std::make_unique<DCE<SpecificModule>>(dte, dev, netif); return std::make_unique<DCE_T<SpecificModule>>(dte, dev, netif);
) )
} }
std::unique_ptr<DCE<GenericModule>> create_generic_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<GenericModule>& dev, esp_netif_t *netif) std::unique_ptr<DCE> create_generic_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<GenericModule>& dev, esp_netif_t *netif)
{ {
return create_dce<GenericModule>(dte, dev, netif); TRY_CATCH_RET_NULL(
return std::make_unique<DCE>(dte, dev, netif);
)
} }
std::unique_ptr<DCE<SIM7600>> create_SIM7600_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<SIM7600>& dev, esp_netif_t *netif) //std::unique_ptr<DCE<SIM7600>> create_SIM7600_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<SIM7600>& dev, esp_netif_t *netif)
{ //{
return create_dce<SIM7600>(dte, dev, netif); // return create_dce<SIM7600>(dte, dev, netif);
} //}
std::unique_ptr<DCE<SIM7600>> create_SIM7600_dce(const std::shared_ptr<DTE>& dte, esp_netif_t *netif, std::string &apn) std::unique_ptr<DCE> create_SIM7600_dce(const std::shared_ptr<DTE>& dte, esp_netif_t *netif, std::string &apn)
{ {
auto pdp = std::make_unique<PdpContext>(apn); auto pdp = std::make_unique<PdpContext>(apn);
auto dev = std::make_shared<SIM7600>(dte, std::move(pdp)); auto dev = std::make_shared<SIM7600>(dte, std::move(pdp));
return create_dce<SIM7600>(dte, std::move(dev), netif); return create_generic_dce_from_module(dte, std::move(dev), netif);
} }
@ -87,7 +89,7 @@ extern "C" esp_modem_dce_t *esp_modem_new(const esp_modem_dte_config_t *config,
extern "C" void esp_modem_destroy(esp_modem_dce_t * dce) extern "C" void esp_modem_destroy(esp_modem_dce_t * dce)
{ {
assert(dce->modem_type == esp_modem_dce_wrap::MODEM_SIM7600); assert(dce->modem_type == esp_modem_dce_wrap::MODEM_SIM7600);
auto dce_sim7600 = static_cast<DCE<SIM7600>*>(dce->dce_ptr); auto dce_sim7600 = static_cast<DCE*>(dce->dce_ptr);
delete dce_sim7600; delete dce_sim7600;
delete dce; delete dce;
} }
@ -95,7 +97,7 @@ extern "C" void esp_modem_destroy(esp_modem_dce_t * dce)
extern "C" esp_err_t esp_modem_set_mode(esp_modem_dce_t * dce, esp_modem_dce_mode_t mode) extern "C" esp_err_t esp_modem_set_mode(esp_modem_dce_t * dce, esp_modem_dce_mode_t mode)
{ {
assert(dce->modem_type == esp_modem_dce_wrap::MODEM_SIM7600); assert(dce->modem_type == esp_modem_dce_wrap::MODEM_SIM7600);
auto dce_sim7600 = static_cast<DCE<SIM7600>*>(dce->dce_ptr); auto dce_sim7600 = static_cast<DCE*>(dce->dce_ptr);
if (mode == ESP_MODEM_MODE_DATA) { if (mode == ESP_MODEM_MODE_DATA) {
dce_sim7600->set_data(); dce_sim7600->set_data();
} else if (mode == ESP_MODEM_MODE_COMMAND) { } else if (mode == ESP_MODEM_MODE_COMMAND) {
@ -109,7 +111,7 @@ extern "C" esp_err_t esp_modem_set_mode(esp_modem_dce_t * dce, esp_modem_dce_mod
extern "C" esp_err_t esp_modem_read_pin(esp_modem_dce_t * dce, bool &x) extern "C" esp_err_t esp_modem_read_pin(esp_modem_dce_t * dce, bool &x)
{ {
assert(dce->modem_type == esp_modem_dce_wrap::MODEM_SIM7600); assert(dce->modem_type == esp_modem_dce_wrap::MODEM_SIM7600);
auto dce_sim7600 = static_cast<DCE<SIM7600>*>(dce->dce_ptr); auto dce_sim7600 = static_cast<DCE*>(dce->dce_ptr);
return command_response_to_esp_err(dce_sim7600->read_pin(x)); return command_response_to_esp_err(dce_sim7600->read_pin(x));
} }

60
esp_modem/src/esp_modem_dce.cpp Normal file
View File

@ -0,0 +1,60 @@
//
// Created by david on 3/24/21.
//
#include "cxx_include/esp_modem_dte.hpp"
#include "cxx_include/esp_modem_dce.hpp"
#include "esp_log.h"
namespace esp_modem::DCE {
bool Modes::set(DTE *dte, ModuleIf *device, PPP &netif, modem_mode m)
{
switch (m) {
case modem_mode::UNDEF:
break;
case modem_mode::COMMAND_MODE:
if (mode == modem_mode::COMMAND_MODE)
return false;
netif.stop();
device->set_mode(modem_mode::COMMAND_MODE);
uint8_t* data;
dte->set_data_cb([&](size_t len) -> bool {
auto actual_len = dte->read(&data, 64);
ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data", data, actual_len, ESP_LOG_INFO);
return false;
});
netif.wait_until_ppp_exits();
dte->set_data_cb(nullptr);
dte->set_mode(modem_mode::COMMAND_MODE);
mode = m;
return true;
case modem_mode::DATA_MODE:
if (mode == modem_mode::DATA_MODE)
return false;
device->setup_data_mode();
device->set_mode(modem_mode::DATA_MODE);
dte->set_mode(modem_mode::DATA_MODE);
netif.start();
mode = m;
return true;
case modem_mode::CMUX_MODE:
if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE)
return false;
device->set_mode(modem_mode::CMUX_MODE);
dte->set_mode(modem_mode::CMUX_MODE);
mode = modem_mode::COMMAND_MODE;
return true;
}
return false;
}
modem_mode Modes::get()
{
return mode;
}
}

24
esp_modem/src/esp_modem_modules.cpp
View File

@ -3,12 +3,26 @@
// //
#include "cxx_include/esp_modem_dce_module.hpp" #include "cxx_include/esp_modem_dce_module.hpp"
#include "generate/esp_modem_command_declare.inc"
command_result SIM7600::get_module_name(std::string& name) #define ARGS0
{ #define ARGS1 , x
name = "7600"; #define _ARGS(x) ARGS ## x
return command_result::OK; #define ARGS(x) _ARGS(x)
} #define TEMPLATE_ARG
#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, arg_nr, MUX_ARG, ...) \
return_type GenericModule::name(__VA_ARGS__) { return esp_modem::dce_commands::name(dte.get() ARGS(arg_nr) ); }
DECLARE_ALL_COMMAND_APIS(return_type name(...) { forwards to esp_modem::dce_commands::name(...) } )
#undef ESP_MODEM_DECLARE_DCE_COMMAND
//command_result SIM7600::get_module_name(std::string& name)
//{
// name = "7600";
// return command_result::OK;
//}
command_result SIM800::get_module_name(std::string& name) command_result SIM800::get_module_name(std::string& name)
{ {

2
esp_modem/src/esp_modem_netif.cpp
View File

@ -53,7 +53,7 @@ esp_err_t PPP::esp_modem_post_attach(esp_netif_t * esp_netif, void * args)
// check if PPP error events are enabled, if not, do enable the error occurred/state changed // check if PPP error events are enabled, if not, do enable the error occurred/state changed
// to notify the modem layer when switching modes // to notify the modem layer when switching modes
esp_netif_ppp_config_t ppp_config; esp_netif_ppp_config_t ppp_config;
esp_netif_ppp_get_params(esp_netif, &ppp_config); // esp_netif_ppp_get_params(esp_netif, &ppp_config);
if (!ppp_config.ppp_error_event_enabled) { if (!ppp_config.ppp_error_event_enabled) {
ppp_config.ppp_error_event_enabled = true; ppp_config.ppp_error_event_enabled = true;
esp_netif_ppp_set_params(esp_netif, &ppp_config); esp_netif_ppp_set_params(esp_netif, &ppp_config);