espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-19 21:42:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

CMUX: Experimental implementation

Browse Source
This commit is contained in:
David Cermak
2021-03-04 20:19:18 +01:00
parent 25f5541199
commit fbb4791af1
19 changed files with 631 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
esp_modem/src/ppp_netif.cpp
View File

@ -15,38 +15,41 @@
// esp_netif_driver_base_t base;
//};
static void on_ppp_changed(void *arg, esp_event_base_t event_base,
void PPP::on_ppp_changed(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
{
ppp *e = (ppp*)arg;
PPP *ppp = (PPP*)arg;
// DTE *e = (DTE*)arg;
std::cout << "on_ppp_changed " << std::endl;
ESP_LOGW("TAG", "PPP state changed event %d", event_id);
if (event_id < NETIF_PP_PHASE_OFFSET) {
ESP_LOGI("TAG", "PPP state changed event %d", event_id);
// only notify the modem on state/error events, ignoring phase transitions
e->notify_ppp_exit();
ppp->signal.set(PPP_EXIT);
// e->notify_ppp_exit();
// e->data_mode_closed();
// esp_modem_notify_ppp_netif_closed(dte);
}
}
static esp_err_t esp_modem_dte_transmit(void *h, void *buffer, size_t len)
esp_err_t PPP::esp_modem_dte_transmit(void *h, void *buffer, size_t len)
{
DTE *e = (DTE*)h;
std::cout << "sending data " << len << std::endl;
if (e->write((uint8_t*)buffer, len) > 0) {
return ESP_OK;
PPP *ppp = (PPP*)h;
if (ppp->signal.is_any(PPP_STARTED)) {
std::cout << "sending data " << len << std::endl;
if (ppp->ppp_dte->write((uint8_t*)buffer, len) > 0) {
return ESP_OK;
}
}
return ESP_FAIL;
}
static esp_err_t esp_modem_post_attach(esp_netif_t * esp_netif, void * args)
esp_err_t PPP::esp_modem_post_attach(esp_netif_t * esp_netif, void * args)
{
auto d = (ppp_netif_driver*)args;
esp_netif_driver_ifconfig_t driver_ifconfig = { };
driver_ifconfig.transmit = esp_modem_dte_transmit;
driver_ifconfig.handle = (void*)d->e;
driver_ifconfig.transmit = PPP::esp_modem_dte_transmit;
driver_ifconfig.handle = (void*)d->ppp;
std::cout << "esp_modem_post_attach " << std::endl;
d->base.netif = esp_netif;
ESP_ERROR_CHECK(esp_netif_set_driver_config(esp_netif, &driver_ifconfig));
@ -54,47 +57,51 @@ static esp_err_t esp_modem_post_attach(esp_netif_t * esp_netif, void * args)
// to notify the modem layer when switching modes
esp_netif_ppp_config_t 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_phase_event_enabled = true;
esp_netif_ppp_set_params(esp_netif, &ppp_config);
// }
}
// ESP_ERROR_CHECK(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, &on_ppp_changed, 0));
return ESP_OK;
}
void ppp::receive(uint8_t *data, size_t len) const
void PPP::receive(uint8_t *data, size_t len)
{
std::cout << "received data " << len << std::endl;
esp_netif_receive(driver.base.netif, data, len, nullptr);
if (signal.is_any(PPP_STARTED)) {
std::cout << "received data " << len << std::endl;
esp_netif_receive(driver.base.netif, data, len, nullptr);
}
}
ppp::ppp(std::shared_ptr<DTE> e, esp_netif_t *ppp_netif):
PPP::PPP(std::shared_ptr<DTE> e, esp_netif_t *ppp_netif):
ppp_dte(std::move(e)), netif(ppp_netif)
{
driver.base.netif = ppp_netif;
driver.e = this->ppp_dte.get();
driver.ppp = this;
driver.base.post_attach = esp_modem_post_attach;
ppp_dte->set_data_cb([&](size_t len){
uint8_t *data;
auto actual_len = ppp_dte->read(&data, len);
return receive(data, actual_len);
});
throw_if_esp_fail(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, &on_ppp_changed, (void*)this));
throw_if_esp_fail(esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_GOT_IP, esp_netif_action_connected, ppp_netif));
throw_if_esp_fail(esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_LOST_IP, esp_netif_action_disconnected, ppp_netif));
throw_if_esp_fail(esp_netif_attach(ppp_netif, &driver));
}
void ppp::start()
void PPP::start()
{
ppp_dte->set_data_cb([&](size_t len) -> bool {
uint8_t *data;
auto actual_len = ppp_dte->read(&data, len);
receive(data, actual_len);
return false;
});
esp_netif_action_start(driver.base.netif, 0, 0, 0);
signal.set(PPP_STARTED);
}
void ppp::stop()
void PPP::stop()
{
std::cout << "esp_netif_action_stop " << std::endl;
esp_netif_action_stop(driver.base.netif, nullptr, 0, nullptr);
signal.clear(PPP_STARTED);
}