esp_modem PPP Fails to Stay Connected or Transfer Data After Registration in CMUX Mode (BG600L, Quectel) (IDFGH-15866)

[michaelboeding]

Answers checklist.

• I have read the documentation for esp-protocols components and the issue is not addressed there.
• I have updated my esp-protocols branch (master or release) to the latest version and checked that the issue is present there.
• I have searched the issue tracker for a similar issue and not found a similar issue.

General issue report

PPP Fails to Stay Connected or Transfer Data After Registration in CMUX Mode (BG600L, Quectel)

Setup

• ESP-IDF Version: v5.2.1
• esp-modem Tag: v1.4.0
• Modem: Quectel BG600L
• Mode: CMUX (AT+CMUX=0)
  • AT commands: DLCI 1
  • PPP data: DLCI 2

Issue Summary

1. On boot, I often see a PPP_DISCONNECTED event immediately after trying to start the connection — even after waiting for +CREG: 0,1 or 0,5.
2. Other times, PPP appears to connect and assigns an IP, but no data transfer works (MQTT and ping both fail indefinitely).
3. Eventually, after many retries, registration stabilizes, but PPP does not reconnect automatically, and I never see the PPP_CONNECTED event again.

When it Works

Sometimes the system connects cleanly:

esp-netif_lwip-ppp: Connected
Modem Connect to PPP Server
IP          : 10.178.19.103
Netmask     : 255.255.255.255
Gateway     : 10.64.64.64
Name Server1: 100.127.0.53
Name Server2: 100.127.1.53

When it Fails

But on many boots, I see:

+CREG: 0,2
+QCSQ: "NOSERVICE"
esp-netif_lwip-ppp: Connection lost
BG600L: Modem Disconnect from PPP Server

Even after registering and getting a strong signal:

+CREG: 0,5
+COPS: 0,0,"AT&T",8
+QNWINFO: "eMTC","310410","LTE BAND 4",2000
+QCSQ: "eMTC",-75,-96,199,-9
MQTT Not connected to the broker
sendData() called but we are not connected to cellular

Observations

• The PPP_DISCONNECTED event fires immediately on many boots.
• I only start PPP after seeing successful registration (+CREG: 0,1 or 0,5).
• The modem reports registration with an operator (+COPS) and signal strength via +QCSQ and +QNWINFO.
• Despite this, data transfer fails or stalls silently.
• There is no retry of PPP connection by esp-modem after disconnection.
• This happens regardless of whether esp_modem_start_ppp() returned ESP_OK.

Questions

1. Is the PPP_DISCONNECTED event on boot expected behavior in CMUX mode?
2. Should I wait for a specific URC or PDP context activation (e.g., AT+CGACT) before starting PPP?
3. Does esp-modem automatically reconnect to PPP after a disconnect in CMUX mode?
4. What’s the recommended way to detect that PPP is truly ready for data (besides ESP_OK)?
5. Is there a clean or recommended way to manually recover and re-initiate a PPP session after it has disconnected?
6. What specific modem states (e.g., searching, registered, attached, PDP active) does esp-modem track internally, and is there a preferred way to hook into these transitions when managing the connection lifecycle manually?

Any guidance would be appreciated. Thanks

[david-cermak]

Is the PPP_DISCONNECTED event on boot expected behavior in CMUX mode?

It's not expected, to should work normally after startup (provided you've got a valid config sequence and good signal). Could you please share your init sequence? I'm not familiar with BG600L, but can quickly check against the datasheet.
I've seen similar issues if the init sequence wasn't 100% correct -- the modem refused to connect for the first time but connected seamlessly after retry.

Also, you're talking about "CMUX mode" -- does it work differently in PPPoS mode?

Should I wait for a specific URC or PDP context activation (e.g., AT+CGACT) before starting PPP?

Depending on your device, but usually it's not needed (after "READY")

Does esp-modem automatically reconnect to PPP after a disconnect in CMUX mode?

It does not. Reconnecting needs to be implemented on application level.

What’s the recommended way to detect that PPP is truly ready for data (besides ESP_OK)?

Probably also device dependent, I just check signal quality.

Is there a clean or recommended way to manually recover and re-initiate a PPP session after it has disconnected?

Switch to command and back to data mode. In CMUX, you can use manual transitions (CMUX-DATA -> CMUX-CMD)

What specific modem states (e.g., searching, registered, attached, PDP active) does esp-modem track internally, and is there a preferred way to hook into these transitions when managing the connection lifecycle manually?

This library doesn't check any specific device states.

[michaelboeding]

Hey @david-cermak, first off thanks for all the answers and support, I really appreciate it. For context I did fully implement my own library for control of this device and just to get a better understanding of how the whole modem communication works. Everything worked on the BG600L except for some issues I had with the CMUX framing....I think this is something I'm doing wrong with the frame types but I haven't been able to figure it out. Point being I could share the library(component) I made to show the sequence there also if thats beneficial - its a fully implementation that covers, data, command, cmux, ppp, and cellular connections for the MDM9205 chipset (BG95, BG77, and BG600L-M3 all use this).

It's not expected, to should work normally after startup (provided you've got a valid config sequence and good signal). Could you please share your init sequence? I'm not familiar with BG600L, but can quickly check against the datasheet.
I've seen similar issues if the init sequence wasn't 100% correct -- the modem refused to connect for the first time but connected seamlessly after retry.

Also, you're talking about "CMUX mode" -- does it work differently in PPPoS mode?

Below is my init sequence for connecting to the network and powering up the device.

 used to setup the cellular module 
void BG600L::setup(){
    ESP_LOGI(TAG, "Setting up BG600L module");
    setState(CellularModuleState::POWERING_UP);

#if defined(CONFIG_BOARD_000003Q_01)
    ESP_LOGI(TAG, "Configuring output enable for the pin level converter");
    //configure the output enable for the pin level converter so that it is enabled and we can communicate with the module 
    gpio_config_t config = {
        .pin_bit_mask = (1ULL << CELLULAR_LVL_CONVERTER_OUTPUT_EN),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
   };
   gpio_config(&config);
   gpio_set_level(CELLULAR_LVL_CONVERTER_OUTPUT_EN, 1);
    //hold the pin in deep sleep 
   gpio_hold_en(CELLULAR_LVL_CONVERTER_OUTPUT_EN);
   //delay for 1 second 
   vTaskDelay(pdMS_TO_TICKS(1000));
#endif

    // Initialize event group
    event_group = xEventGroupCreate();

    // Power up the module
    if (!this->powerUp()) {
        ESP_LOGE(TAG, "Failed to power up module");
       
        return;
    }

    ESP_LOGI(TAG, "BG600L finished power up sequence");
    // Initialize ESP-NETIF after power up
    ESP_ERROR_CHECK(esp_netif_init());
    //ESP_ERROR_CHECK(esp_event_loop_create_default()); this is already called in the setup function for this project
    //log the apn
    ESP_LOGI(TAG, "APN: %s", this->apn.c_str());
    // Configure the PPP netif 
    esp_modem_dce_config dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG(this->apn.c_str());
    esp_netif_config_t netif_ppp_config = ESP_NETIF_DEFAULT_PPP();
    
    // Check if esp_netif already exists before creating a new one
    if (this->esp_netif == nullptr) {
        esp_netif = esp_netif_new(&netif_ppp_config);
        if (!esp_netif) {
            ESP_LOGE(TAG, "Failed to create ESP netif");
            return;
        }
        ESP_LOGI(TAG, "Created new ESP netif");
    } else {
        ESP_LOGI(TAG, "ESP netif already exists, skipping creation");
    }

    // Configure the DTE - which is the MCU UART
    esp_modem_dte_config dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
    dte_config.uart_config.port_num = CELLULAR_UART_NUM;
    dte_config.uart_config.tx_io_num = PIN_CELLULAR_TX;
    dte_config.uart_config.rx_io_num = PIN_CELLULAR_RX;
    dte_config.uart_config.rts_io_num = PIN_CELLULAR_RTS;
    dte_config.uart_config.cts_io_num = PIN_CELLULAR_CTS;
    dte_config.uart_config.flow_control = ESP_MODEM_FLOW_CONTROL_HW;
    dte_config.uart_config.rx_buffer_size = 8192;
    dte_config.uart_config.tx_buffer_size = 2048;
    dte_config.uart_config.event_queue_size = 30;
    dte_config.uart_config.baud_rate = 115200;
#ifdef CONFIG_USE_EXTERNAL_CRYSTAL // Use XTAL if Kconfig option is set to use external crystal
    ESP_LOGI(TAG, "Using external crystal");
    dte_config.uart_config.source_clk = UART_SCLK_XTAL; //todo switch this back to xtla but testing for now with ble low disabled 
#else
    ESP_LOGI(TAG, "Using internal clock");
    dte_config.uart_config.source_clk = UART_SCLK_APB; // Default to APB clock
#endif
    dte_config.task_stack_size = 4096;
    dte_config.task_priority = configMAX_PRIORITIES - 1;
    dte_config.dte_buffer_size = 2048;
    ESP_LOGI(TAG, "Initializing esp_modem for the BG600L module...");
    // Create DTE first - again this is the MCU UART
    this->dte = esp_modem::create_uart_dte(&dte_config);
    if (!this->dte) {
        ESP_LOGE(TAG, "Failed to create UART DTE");
        return;
    }

    this->dte->set_error_cb([](esp_modem::terminal_error err) {
        ESP_LOGE(TAG, "DTE reported terminal error: %d", static_cast<int>(err));
    });


    ESP_LOGI(TAG, "UART DTE created successfully");
    vTaskDelay(pdMS_TO_TICKS(1000));
    
    // Create DCE using the DTE
    //dce = esp_modem::create_generic_dce(&dce_config, dte, esp_netif);
    this->dce = create_BG600L_GNSS_dce(&dce_config, dte, esp_netif);
    if (!this->dce) {
        ESP_LOGE(TAG, "Failed to create DCE");
        return;
    }
    ESP_LOGI(TAG, "DCE created successfully");
    vTaskDelay(pdMS_TO_TICKS(1000));

     // Set flow control if needed
    if (dte_config.uart_config.flow_control == ESP_MODEM_FLOW_CONTROL_HW) {
        esp_modem::command_result result = this->dce->set_flow_control(2, 2);
        
        if (result != esp_modem::command_result::OK) {
            ESP_LOGE(TAG, "Failed to set flow control");
        } else {
            ESP_LOGI(TAG, "HW flow control OK");
        }
    }else if (dte_config.uart_config.flow_control == ESP_MODEM_FLOW_CONTROL_SW){
        esp_modem::command_result result = this->dce->set_flow_control(0, 0);
        if (result != esp_modem::command_result::OK) {
            ESP_LOGE(TAG, "Failed to set software flow control");
        } else {
            ESP_LOGI(TAG, "SW flow control OK");
        }
    }
    vTaskDelay(pdMS_TO_TICKS(1000));
    

   
    // Enable verbose +CME ERROR responses
    esp_modem::command_result result = this->dce->config_mobile_termination_error(2);
    if (result != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to enable verbose +CME ERROR responses");
    } else {
        ESP_LOGI(TAG, "Verbose +CME ERROR responses enabled");
    }

    


    // Now that DTE/DCE are initialized, register for events
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, &on_ip_event, this));
    ESP_ERROR_CHECK(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, &on_ppp_changed, this));

   if (!this->dce->set_mode(esp_modem::modem_mode::CMUX_MODE)) {
        ESP_LOGE(TAG, "Failed to set CMUX mode for the DCE");
    } else {
        ESP_LOGI(TAG, "CMUX mode set successfully for the DCE");
        //set the urc callback for the dce
        this->dce->set_urc([this](uint8_t *data, size_t len) {
            ESP_LOGD(TAG, "Urc callback received");
            return this->urc_callback(data, len);
        });
    }
    //delay for 1 second to give the module time to enter CMUX mode
    vTaskDelay(pdMS_TO_TICKS(1000));

    //get the DCE to CMUX mode which is the modem itself - this handles setting the dte to CMUX mode as well
    esp_modem::modem_mode mode = this->dce->get_mode();
    ESP_LOGI(TAG, "Current Mode: %d", mode);

    //delay for 1 second to give the module time to enter CMUX mode
    vTaskDelay(pdMS_TO_TICKS(1000));

    // Initial sync and basic AT commands
    auto sync_result = this->dce->sync();
    if(sync_result != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to sync");
        //something is wrong here - restart the module
        //this->reboot();
    } else {
        ESP_LOGI(TAG, "Sync OK");
    }
    vTaskDelay(pdMS_TO_TICKS(1000));

    //disable the DTR signal
    this->disableDTR();

    //enable the fast power off
    this->enableFastPowerOff(true, 11);

    //configure the eDRX settings
    ESP_LOGI(TAG, "Configuring eDRX settings...");
    // Example: Enable eDRX for LTE-M, request 20.48s cycle, 10.24s PTW
    // Use mode 1 (Enable) or 2 (Enable + URC) depending on if you want URCs for eDRX changes
    // Use ACT 4 for LTE-M
    // // Example: Enable eDRX for LTE-M (4), request 10.24s PTW ("0111"), 20.48s cycle ("0010")
    //esp_modem::command_result edrx_res = this->configEdrx(1, 4, "0111", "0010");
    //if (edrx_res != esp_modem::command_result::OK) {
    //    ESP_LOGE(TAG, "Failed to configure eDRX settings.");
    //    // Decide if this is critical - maybe just log warning?
    //} else {
    //     ESP_LOGI(TAG, "eDRX settings configured (requested).");
    //}

    //MARK: Get basic module information
    this->imei = this->requestImei();
    this->imsi = this->requestImsi();
    this->iccid = this->requestIccid();
    this->modelString = this->requestModelString();
    this->manufacturerIdentification = this->requestManufacturerId();
    this->firmwareVersion = this->requestFirmwareVersion();


    setState(CellularModuleState::POWERED_UP);
    ESP_LOGI(TAG, "BG600L setup completed successfully");
}

Also as far as I'm concerned it doesn't work differently.

Depending on your device, but usually it's not needed (after "READY")

Got it - I added a check for a couple more conditions in my connectToNetwork() method

int32_t BG600L::connectToNetwork(){
    // 1. Make sure modem and esp‑netif are set up (you already do this) 

    //check if the module is already connected to the network
    if (!this->isInitialized()){
        ESP_LOGE(TAG, "BG600L is not initialized");
        this->setup();
    }

    //set the pdp context
    esp_modem::PdpContext pdp("soracom.io");
    this->dce->get_module()->configure_pdp_context(std::make_unique<esp_modem::PdpContext>(pdp));


    //delay for 1 second to give the module time to enter CMUX mode
    vTaskDelay(pdMS_TO_TICKS(1000));
    //switch to switchToWwanPriorityMode
    auto resultPriority = this->switchToWwanPriorityMode();
    if(resultPriority != esp_modem::command_result::OK){
        ESP_LOGE(TAG, "Failed to switch to wwan priority mode");
    } else {
        ESP_LOGI(TAG, "Switched to wwan priority mode");
    }

    //enable fast power off
    auto resultFastPowerOff = this->enableFastPowerOff(true, 11);
    if(resultFastPowerOff != esp_modem::command_result::OK){
        ESP_LOGE(TAG, "Failed to enable fast power off");
    } else {
        ESP_LOGI(TAG, "Enabled fast power off");
    }

    //delay for 1 second
    vTaskDelay(pdMS_TO_TICKS(1000));


    // 2. Bring up registration 
    if (waitForNetworkRegistration(180) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to bring up registration");
        //return -1;                        // registration failed / timed‑out
    }

    //wait for ps attach
    if (waitForPsAttach(140) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to wait for PS attach");
        //return -2;                        // ATD*99# / CMUX error
    }

    // 3. Resume PPP so LWIP starts the negotiation 
    if (resumeNetworkInterface() != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to resume network interface");
        //return -2;                        // ATD*99# / CMUX error
    }

    // 4. Block until we really have an IP address 
    if (waitForPppIp(60) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to get PPP IP address");
        //return -3;                        // no IP
    }

    // set system clock so TLS/MQTT hand‑shakes don’t choke 
    syncSystemClockFromNetwork();



    ESP_LOGI(TAG, "Network ready – safe to start MQTT");
    return 1;                             // success
}


//supplement methods 


// -----------------------------------------------------------------------------
//  Enable unsolicited registration URCs (+CREG,+CGREG,+CEREG) with cause field
// -----------------------------------------------------------------------------
esp_modem::command_result BG600L::enableRegistrationStatusUrcs(){
    if (!dce) {
        ESP_LOGE(TAG, "DCE not initialised – cannot enable URCs");
        return esp_modem::command_result::FAIL;
    }

    /*  +CREG: 2   → registration + location info (LAC/CI/AcT)                */
    /*  +CGREG:2   → GPRS attach status + location info                        */
    /*  +CEREG:2   → EPS attach status + location info + reject‑cause bytes    */
    static const char *const cmds[] = {
        "AT+CREG=2\r",
        "AT+CGREG=2\r",
        "AT+CEREG=2\r"      /* type 5 adds <cause_type>,<reject_cause> */
    };

    for (const char *cmd : cmds) {
        esp_modem::command_result r =
            esp_modem::dce_commands::generic_command(dte.get(), cmd, "OK", "ERROR", 300);
        if (r != esp_modem::command_result::OK) {
            ESP_LOGE(TAG, "Failed to execute %s", cmd);
            return esp_modem::command_result::FAIL;
        }
    }

    ESP_LOGI(TAG, "Registration URCs enabled (CREG=2, CGREG=2, CEREG=2)");
    return esp_modem::command_result::OK;
}

// -----------------------------------------------------------------------------
//  Wait until +CEREG/+CREG/+CGREG show Registered (stat 1 or 5)
// -----------------------------------------------------------------------------
esp_modem::command_result BG600L::waitForNetworkRegistration(int timeout_seconds){
    if (!dce) {
        ESP_LOGE(TAG, "DCE not initialised – cannot wait for registration");
        return esp_modem::command_result::FAIL;
    }

    // Make sure URCs are on so we see changes as soon as they happen.        
    if (enableRegistrationStatusUrcs() != esp_modem::command_result::OK) {
        return esp_modem::command_result::FAIL;
    }

    const TickType_t t0   = xTaskGetTickCount();
    const TickType_t tEnd = t0 + pdMS_TO_TICKS(timeout_seconds * 1000);

    std::string rsp;

    while (xTaskGetTickCount() < tEnd) {
        // Poll CEREG? (covers LTE‑M/NB‑IoT) first – fastest for most Soracom
        // deployments, falls back to CREG if module isn’t in EPS RAT yet.    
        bool registered = false;

        if (dce->at("AT+CEREG?", rsp, 500) == esp_modem::command_result::OK) {
            int stat = -1;
            ESP_LOGI(TAG, "CEREG response: %s", rsp.c_str());
            if (sscanf(rsp.c_str(), "%*[^,],%d", &stat) == 1 && (stat == 1 || stat == 5)) {
                registered = true;
            }
        }

        // Fallback: GSM registration (very rare for BG600L Cat‑M build)     
        if (!registered &&
            dce->at("AT+CREG?", rsp, 500) == esp_modem::command_result::OK) {
            ESP_LOGI(TAG, "CREG response: %s", rsp.c_str());
            int stat = -1;
            if (sscanf(rsp.c_str(), "%*[^,],%d", &stat) == 1 && (stat == 1 || stat == 5)) {
                registered = true;
            }
        }

        if (registered) {
            ESP_LOGI(TAG, "Modem is registered to network (stat 1/5)");
            return esp_modem::command_result::OK;
        }

        // Optional: short log each 5 s so user sees progress. 
        static uint32_t lastLog = 0;
        if ((xTaskGetTickCount() - lastLog) > pdMS_TO_TICKS(5000)) {
            lastLog = xTaskGetTickCount();
            ESP_LOGI(TAG, "Waiting for registration…");
        }

        vTaskDelay(pdMS_TO_TICKS(1000));
    }

    ESP_LOGE(TAG, "Registration timed‑out after %d s", timeout_seconds);
    return esp_modem::command_result::TIMEOUT;
}

// -----------------------------------------------------------------------------
//  Wait until esp‑netif PPP has an IPv4 address (IP_EVENT_PPP_GOT_IP already
//  sets CONNECT_BIT in your on_ip_event handler, so we just wait on it).
// -----------------------------------------------------------------------------
esp_modem::command_result BG600L::waitForPppIp(int timeout_seconds){
    if (!esp_netif) {
        ESP_LOGE(TAG, "esp_netif not initialised – cannot wait for IP");
        return esp_modem::command_result::FAIL;
    }

    EventBits_t bits = xEventGroupWaitBits(event_group,
                                           CONNECT_BIT,
                                           pdFALSE,            /* keep bit set */
                                           pdTRUE,             /* wait for all bits */
                                           pdMS_TO_TICKS(timeout_seconds * 1000));

    if (bits & CONNECT_BIT) {
        esp_netif_ip_info_t ip;
        if (esp_netif_get_ip_info(esp_netif, &ip) == ESP_OK && ip.ip.addr != 0) {
            ESP_LOGI(TAG, "PPP interface has IP: " IPSTR, IP2STR(&ip.ip));
            return esp_modem::command_result::OK;
        }
    }

    ESP_LOGE(TAG, "Timed‑out waiting for IP address (%d s)", timeout_seconds);
    return esp_modem::command_result::TIMEOUT;
}

//-------------------------------------------------------------------------
//  Block until the PS domain is attached (CGATT:1) or the timeout expires
//-------------------------------------------------------------------------
esp_modem::command_result BG600L::waitForPsAttach(uint32_t timeout_seconds){
    if (!dce) {
        ESP_LOGE(TAG, "DCE not initialised – cannot wait for PS attach");
        return esp_modem::command_result::FAIL;
    }

    const TickType_t tEnd = xTaskGetTickCount() + pdMS_TO_TICKS(timeout_seconds * 1000);
    std::string response;

    while (xTaskGetTickCount() < tEnd) {
        if (dce->at("AT+CGATT?", response, 300) == esp_modem::command_result::OK &&
            response.find(": 1") != std::string::npos)                // +CGATT: 1 == attached
        {
            ESP_LOGI(TAG, "PS attached");
            return esp_modem::command_result::OK;
        }
        vTaskDelay(pdMS_TO_TICKS(500));
    }

    ESP_LOGE(TAG, "Timed‑out waiting for PS attach (%u s)", timeout_seconds);
    return esp_modem::command_result::TIMEOUT;
}

//------------------------------------------------------------------
//  Returns OK if PS domain is attached, FAIL otherwise
//------------------------------------------------------------------
esp_modem::command_result BG600L::isPsAttached(){
    if (!dce) {
        ESP_LOGE(TAG, "DCE not initialised – cannot check PS attachment");
        return esp_modem::command_result::FAIL;
    }

    std::string response;
    if (dce->at("AT+CGATT?", response, 300) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to check PS attachment");
        return esp_modem::command_result::FAIL;
    }
    // Expected:  +CGATT: <state>   where state 1 = attached 
    ESP_LOGI(TAG, "PS attachment check response: %s", response.c_str());
    return (response.find(": 1") != std::string::npos)
             ? esp_modem::command_result::OK
             : esp_modem::command_result::FAIL;
}

//------------------------------------------------------------------
//  Pull network time (AT+QLTS) and feed it to the ESP‑IDF RTC
//------------------------------------------------------------------
esp_modem::command_result BG600L::syncSystemClockFromNetwork(){
    if (!dce) {
        ESP_LOGE(TAG, "DCE not initialised – cannot sync system clock");
        return esp_modem::command_result::FAIL;
    }

    std::string response;
    if (dce->at("AT+QLTS", response, 500) != esp_modem::command_result::OK) {
        return esp_modem::command_result::FAIL;
    }
    /* Response: +QLTS: "yy/MM/dd,hh:mm:ss±zz"  */
    int yy, MM, dd, hh, mm, ss, tz;
    if (sscanf(response.c_str(), "+QLTS: \"%2d/%2d/%2d,%2d:%2d:%2d%3d\"",
               &yy, &MM, &dd, &hh, &mm, &ss, &tz) != 7) {
        return esp_modem::command_result::FAIL;   // parse error
    }
    struct tm t = {};
    t.tm_year = 2000 + yy - 1900;
    t.tm_mon  = MM - 1;
    t.tm_mday = dd;
    t.tm_hour = hh;
    t.tm_min  = mm;
    t.tm_sec  = ss;
    time_t utc = my_timegm(&t) - tz * 15 * 60;   // Quectel TZ units = 15 min
    struct timeval tv = { .tv_sec = utc, .tv_usec = 0 };
    settimeofday(&tv, nullptr);

    ESP_LOGI(TAG, "System clock synchronised to %04d-%02d-%02d %02d:%02d:%02d",
             2000+yy, MM, dd, hh, mm, ss);
    return esp_modem::command_result::OK;
}

It does not. Reconnecting needs to be implemented on application level.

What does this look like exactly (how would I implement the reconnecting of the network interface using the esp-modem component objects? I guess this part is a little confusing for me from a flow because it seems everything comes up by itself - the device searches and connects and then links to ppp by default. So I guess I would assume it would auto reconnect once it comes back into service? Would it make more sense to break out some of these into separate commands so the end user has more control? Like a connectToNetwork, attachToPPP , and maybe the ability to change a setting to have the esp-modem component automatically handle the reconnecting since it automatically handles the rest?

Probably also device dependent, I just check signal quality.

Good idea - I will add this to my current checks for registration status before saying I am 'connected` to the network.

Switch to command and back to data mode. In CMUX, you can use manual transitions (CMUX-DATA -> CMUX-CMD)

For the manual transitions I guess this is a little confusing to me also - since I am currently using the CMUX_MODE. I thought it was all handled internally. And I couldn't use any of the manual transitions since I was in this mode?

enum class modem_mode {
    UNDEF,
    COMMAND_MODE, /*!< Command mode -- the modem is supposed to send AT commands in this mode */
    DATA_MODE,    /*!< Data mode -- the modem communicates with network interface on PPP protocol */
    DUAL_MODE,    /*!< Dual mode -- the modem has two real terminals. Data and commands work at the same time */
    CMUX_MODE,    /*!< CMUX (Multiplex mode) -- Simplified CMUX mode, which creates two virtual terminals,
                   *  assigning one solely to command interface and the other  to the data mode */
    CMUX_MANUAL_MODE,    /*!< Enter CMUX mode manually -- just creates two virtual terminals */
    CMUX_MANUAL_EXIT,    /*!< Exits CMUX mode manually -- just destroys two virtual terminals */
    CMUX_MANUAL_DATA,    /*!< Sets the primary terminal to DATA mode in manual CMUX */
    CMUX_MANUAL_COMMAND, /*!< Sets the primary terminal to COMMAND mode in manual CMUX */
    CMUX_MANUAL_SWAP,    /*!< Swaps virtual terminals in manual CMUX mode (primary <-> secondary) */
    RESUME_DATA_MODE,    /*!< This is used when the device is already in DATA mode and we need the modem lib to
                          * enter the mode without switching. On success, we would end up in DATA-mode, UNDEF otherwise */
    RESUME_COMMAND_MODE, /*!< This is used when the device is already in COMMAND mode and we want to resume it
                          * On success, we would end up in DATA-mode, UNDEF otherwise */
    RESUME_CMUX_MANUAL_MODE, /*!< This is used when the device is already in CMUX mode and we need the modem lib to
                              * enter it without switching. On success, we would end up in CMUX_MANUAL-mode, UNDEF otherwise */
    RESUME_CMUX_MANUAL_DATA, /*!< This is used when the device is already in CMUX-DATA mode and we need the modem lib to
                              * enter it without switching. On success, we would end up in CMUX_MANUAL-DATA mode, UNDEF otherwise */
    AUTODETECT,              /*!< Auto-detection command: It tries to send a few packets in order to recognize which mode the
                              * the device currently is and update the modem library mode. On success the modem is updated,
                              * otherwise it's set to UNDEF */
};

Also to add to this in my implementation I had created in my own library when I go into CMUX mode I create the following channels

/**
 * @brief Enables CMUX mode by sending AT+CMUX, then opens Control (DLCI 0)
 * and default application channels (DLCI 0, 1, 2).
 * @param config The MUX configuration to use.
 * @return CommandResult::OK on success, FAIL/TIMEOUT otherwise.
 */
CommandResult CMUXSession::enableCMUX(const MuxConfig& config) {
    ESP_LOGD(TAG, "Enabling CMUX mode..."); 

    if (isMuxActive) {
        ESP_LOGD(TAG, "CMUX mode is already active.");
        return CommandResult::OK;
    }
    if (!this->mux) { // Use muxHandler consistently
        ESP_LOGE(TAG, "Mux Handler is NULL! Cannot enable CMUX.");
        return CommandResult::FAIL;
    }

    //disable hardware flow control
    
    /*
    CommandResult flowControlResult = this->modem->disableHardwareFlowControl();
    if (flowControlResult != CommandResult::OK) {
        ESP_LOGE(TAG, "Failed to disable hardware flow control");
    }else{
        ESP_LOGI(TAG, "Hardware flow control disabled successfully");
    }
    */
    
    
    //enable hardware flow control
    CommandResult flowControlResult = this->modem->enableHardwareFlowControl();
    if (flowControlResult != CommandResult::OK) {
        ESP_LOGE(TAG, "Failed to enable hardware flow control");
        //return flowControlResult;
    }else{
        ESP_LOGD(TAG, "Hardware flow control enabled successfully");
    }
    

    ESP_LOGD(TAG, "Enabling CMUX mode via MUX...");

    // --- Step 1: Send AT+CMUX Command (via MUX::enable) ---
    // MUX::enable uses the *underlying ATClient* because MUX framing isn't active yet.
    CommandResult result = this->mux->enable(config);
    if (result != CommandResult::OK) {
        ESP_LOGE(TAG, "MUX failed to enable CMUX mode (AT+CMUX command failed).");
        isMuxActive = false; // Ensure flag is false
        return result; // Propagate the error (FAIL or TIMEOUT)
    }else{
        ESP_LOGD(TAG, "CMUX mode enabled successfully");
        isMuxActive = true; // MUX framing starts NOW
        this->sessionType = SessionType::CMUX; // Update session type tracking
    }

    // --- Step 2: AT+CMUX Succeeded - Set MUX Active & Open Channels ---
    ESP_LOGD(TAG, "AT+CMUX OK received. MUX framing should now be active.");
    isMuxActive = true; // MUX framing starts NOW

    //delay for 3 seconds to give the module time to start the mux
    vTaskDelay(3000 / portTICK_PERIOD_MS);

    // --- Step 3: Open Control Channel (DLCI 0) ---
    // This now happens over MUX framing. MUX::openChannel handles SABM/UA.
    ESP_LOGD(TAG, "Opening Control Channel (DLCI 0)...");
    result = this->mux->openChannel(0, ChannelType::CONTROL);
    if (result != CommandResult::OK) {
        ESP_LOGE(TAG, "Failed to open Control Channel (DLCI 0). Disabling MUX attempt.");
        // Attempt to revert - disable might fail if control channel isn't open, but try anyway.
        disableCMUX(); // This will set isMuxActive = false
        return CommandResult::FAIL;
    }else{
        ESP_LOGD(TAG, "Control Channel (DLCI 0) opened successfully.");
    }

    //delay for 1 second to give the module time to start the mux
    vTaskDelay(1000 / portTICK_PERIOD_MS);

    // --- Step 4: Open Command Channel (DLCI 1) ---
    ESP_LOGD(TAG, "Opening Command Channel (DLCI %d)...", COMMAND_DLCI);
    result = this->mux->openChannel(COMMAND_DLCI, ChannelType::COMMAND);
    if (result != CommandResult::OK) {
        ESP_LOGE(TAG, "Failed to open Command Channel (DLCI %d). Disabling MUX.", COMMAND_DLCI);
        this->mux->closeChannel(0); // Try to close control channel
        disableCMUX(); // Attempt to clean up
        return CommandResult::FAIL;
    }else{
        ESP_LOGD(TAG, "Command Channel (DLCI %d) opened successfully.", COMMAND_DLCI);
    }

    //delay for 1 second to give the module time to start the mux
    vTaskDelay(1000 / portTICK_PERIOD_MS);

    
    // --- Step 5: Open Data Channel (DLCI 2) ---
    ESP_LOGD(TAG, "Opening Data Channel (DLCI %d)...", DATA_DLCI);
    result = this->mux->openChannel(DATA_DLCI, ChannelType::DATA);
     if (result != CommandResult::OK) {
        ESP_LOGE(TAG, "Failed to open Data Channel (DLCI %d). Disabling MUX.", DATA_DLCI);
        this->mux->closeChannel(COMMAND_DLCI); // Try closing previous
        this->mux->closeChannel(0);            // Try closing control
        disableCMUX(); // Attempt to clean up
        return CommandResult::FAIL;
    }else{
        ESP_LOGD(TAG, "Data Channel (DLCI %d) opened successfully.", DATA_DLCI);
    }

    //delay for 1 second to give the module time to start the mux
    vTaskDelay(1000 / portTICK_PERIOD_MS);


    // --- Step 6: Final Success ---
    ESP_LOGD(TAG, "CMUX mode fully enabled and default channels (0, %d, %d) opened.", COMMAND_DLCI, DATA_DLCI);
    this->sessionType = SessionType::CMUX; // Update session type tracking
    return CommandResult::OK;
}

So basically I create the Control, Command, and Data channel so they are all up always. I think this matches your implementation - and then I just route through the correct channels internally - eg an AT command is sent it routes over the command channel, and the DATA etc is routed through the other channel and then I forward it to the PPP interface or vice versa. Is that what the esp-modem component does internally - auto handle that? I guess what I'm asking is if it auto handles it like the above then why is the manual transitions required?

This library doesn't check any specific device states.

Would it make sense to have some extra states and callbacks for extra events etc? Maybe not as detailed as this but for example In my library I have all of the below - maybe not as detailed as I have built out but something to give us more control through events etc?

/**
 * @brief Interface for handling cellular network events
 * 
 * This interface defines the methods that must be implemented by classes
 * that want to handle cellular network events.
 * 
 */

class I_CellularNetworkCallbacks {
    public:

        /**
         * @brief Method called when the network registration status changes
         * @param status The new network registration status
         * @note Before a cellular modem can access data services, it must first register with a network operator
         */
        virtual void onNetworkRegistrationStatusChanged(CellularNetwork* network, NetworkRegistrationStatus status) {
            //default implementation
        }

         /**
         * @brief Method called when the operator is selected
         * @param operatorInfo The operator info
         */
        virtual void onOperatorSelected(CellularNetwork* network, const OperatorInfo& operatorInfo) {
            //default implementation
        }

        /**
         * @brief Method called when the data session is ready - when the modem has been configured with the APN PDP context etc
         * @param network The network instance
         * @note Once this happens you can go ahead and create the PPP interface and connect to the internet 
         */
        virtual void onDataSessionReady(CellularNetwork* network) {
            //default implementation
        }

        /**
         * @brief Called when a data session is established or lost.
         * @param cid Context identifier.
         * @param active True if the data session is active, false otherwise.
         */
        virtual void onDataSessionStateChanged(CellularNetwork* network, int cid, bool active) {
            // Default implementation
        }

        /**
         * @brief Called when the modem receives an IP address.
         * @param cid Context identifier.
         * @param ipAddress Assigned IP address.
         */
        virtual void onIpAddressAssigned(CellularNetwork* network, int cid, const std::string& ipAddress) {
            // Default implementation
        }

        /**
         * @brief Called when the detailed network status changes.
         * 
         * This method is called when the detailed network status (as defined by
         * the NetworkStatus enum) changes. This provides more detailed status
         * information than the basic NetworkRegistrationStatus.
         * 
         * @param network The network instance
         * @param status The new detailed network status
         */
        virtual void onNetworkStatusChanged(CellularNetwork* network, NetworkStatus status) {
            // Default implementation
        }
        
};



class I_CellularPPPCallbacks {
    public:
        /**
         * @brief Called when the PPP connection is established
         * 
         */
        virtual void onPPPConnected(CellularPPP* ppp) {
            //default implementation
        }
        /**
         * @brief Called when the PPP connection is disconnected
         * 
         */
        virtual void onPPPDisconnected(CellularPPP* ppp) {
            //default implementation
        }

        /**
         * @brief Called when the PPP connection is running from the PPP Phase running event
         * 
         */
        virtual void onPPPRunning(CellularPPP* ppp) {
            //default implementation
        }

};

Thanks again for all the help and clarification - I think im close on this implementation just want to make sure it's perfect before I ship it to production.

[michaelboeding]

1. I still see the disconnected event sometimes on boot - but I think that may be a separate problem as you mentioned above.

2. I have been working on putting something together for the reconnect logic. And from what I understand so far the network is automatically connecting/reconning at the module level. But the PPP needs to be reconnected anytime we have the NETIF_PPP_ERRORCONNECT NETIF_PPP_ERRORPEERDEAD NETIF_PPP_PHASE_ESTABLISH NETIF_PPP_PHASE_DISCONNECT . So when that happens I should call the reconnect ppp logic - assuming I make sure the network is connected and up before I call the reconnect? Would something like the below be correct? Or do I need to use all the MANUAL CMUX modes?

3. Also what allows the initial PPP connection? If the library doesn't handle this what causes it to connect initially and work and just when it drops it stops working?

//method used to reconnect PPP after disconnection
esp_modem::command_result BG600L::reconnectPPP() {
    ESP_LOGI(TAG, "Reconnecting PPP...");
    
    // Clear the connect bit first
    xEventGroupClearBits(event_group, CONNECT_BIT);

    //go to command mode
    bool result = this->dce->set_mode(esp_modem::modem_mode::COMMAND_MODE);
    if(result != true){
        ESP_LOGE(TAG, "Failed to go to command mode");
        return esp_modem::command_result::FAIL;
    }
    ESP_LOGI(TAG, "Command mode set");

    //delay for 1 second
    vTaskDelay(pdMS_TO_TICKS(1000));

    // Hang up the PPP connection, but only try once (no double call)
    esp_modem::command_result hangUpResult = this->dce->hang_up();
    if (hangUpResult != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to hang up PPP connection");
        return esp_modem::command_result::FAIL;
    }
    ESP_LOGI(TAG, "PPP connection hung up");

    //delay for 250ms
    vTaskDelay(pdMS_TO_TICKS(250));

    /* 1. Flush the old link so LWIP closes the PCB cleanly                 */
    esp_modem::command_result pauseResult = this->dce->pause_netif(true, true, 1000);                  // 100 ms is enough
    if(pauseResult != esp_modem::command_result::OK){
        ESP_LOGE(TAG, "Failed to pause network interface");
        return esp_modem::command_result::FAIL;
    }
    ESP_LOGI(TAG, "Network interface paused");
    vTaskDelay(pdMS_TO_TICKS(200));
    ESP_LOGI(TAG, "Network interface paused for 200ms");

    //go to CMUX mode
    result = this->dce->set_mode(esp_modem::modem_mode::CMUX_MODE);
    if(result != true){
        ESP_LOGE(TAG, "Failed to go to CMUX mode");
        return esp_modem::command_result::FAIL;
    }
    ESP_LOGI(TAG, "CMUX mode set");

    /* 3.  UN‑pause the interface – this is the trigger that makes LWIP
     *     start a new LCP negotiation over the CMUX‑data DLCI.             */
    if (resumeNetworkInterface() != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to resume network interface");
        return esp_modem::command_result::FAIL;
    }
    
    
    // First check if we're still registered
    if (waitForNetworkRegistration(30) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Lost network registration during PPP reconnect");
        return esp_modem::command_result::FAIL;
    }
    
    // Check PS attachment
    if (isPsAttached() != esp_modem::command_result::OK) {
        ESP_LOGI(TAG, "PS not attached, waiting...");
        if (waitForPsAttach(30) != esp_modem::command_result::OK) {
            ESP_LOGE(TAG, "PS attach failed during PPP reconnect");
            return esp_modem::command_result::FAIL;
        }
    }
    
    // Wait for PPP to come up with IP
    if (waitForPppIp(30) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to get IP after PPP reconnect");
        return esp_modem::command_result::FAIL;
    }
    
    ESP_LOGI(TAG, "PPP reconnected successfully");
    return esp_modem::command_result::OK;
}

[david-cermak]

1. I would probably look into that boot problem, since it's perfectly repeatable and you're starting from a fresh state on both sides. And it could be related. Moreover if it works with your library. I do not see this issue with any of the modem I played with.

2. Some simple retry logic is here:

esp-protocols/examples/esp_netif/multiple_netifs/main/ppp_connect_esp_modem.c

Lines 55 to 93 in 84b61dc

	while (!ppp_info->stop_task) {
	vTaskDelay(pdMS_TO_TICKS(backoff_time));
	if (ppp_info->parent.connected) {
	backoff_time = 5000;
	continue;
	}
	// try if the modem got stuck in data mode
	ESP_LOGI(TAG, "Trying to Sync with modem");
	ret = esp_modem_sync(dce);
	if (ret != ESP_OK) {
	ESP_LOGI(TAG, "Switching to command mode");
	esp_modem_set_mode(dce, ESP_MODEM_MODE_COMMAND);
	ESP_LOGI(TAG, "Retry sync 3 times");
	for (int i = 0; i < 3; ++i) {
	ret = esp_modem_sync(dce);
	if (ret == ESP_OK) {
	break;
	}
	vTaskDelay(pdMS_TO_TICKS(1000));
	}
	if (ret != ESP_OK) {
	CONTINUE_LATER();
	}
	}
	ESP_LOGI(TAG, "Manual hang-up before reconnecting");
	ret = esp_modem_at(dce, "ATH", NULL, 2000);
	if (ret != ESP_OK) {
	CONTINUE_LATER();
	}
	ret = esp_modem_get_signal_quality(dce, &rssi, &ber);
	if (ret != ESP_OK) {
	CONTINUE_LATER();
	}
	ESP_LOGI(TAG, "Signal quality: rssi=%d, ber=%d", rssi, ber);
	ret = esp_modem_set_mode(dce, ESP_MODEM_MODE_DATA);
	if (ret != ESP_OK) {
	CONTINUE_LATER();
	}
	}

About manual transitions in CMUX -- Yes, it'd suggest using them, because it's just like working with plain PPP/CMD, just handling virtual terminals separately.
It's also possible to use CMUX mode directly (enter and exit -> set_mode(CMUX )and set_mode(CMD)), but I have seen issues with exiting CMUX with many devices, while exiting PPP is more stable, better supported and works universally. CMUX manual modes just help you to keep the other virtual terminal for commands.

3. This library only handles switching modes, so whenever you switch to PPP it tries to connect. If PPP drops, you'd eventually get an event, but the state is not updated automatically -- which probably calls for improvement, at least for the CMUX (auto) mode.
   Currently, the application should handle:

• switching to PPP
• watch for disconnection
  • if disconnected switch back to CMD and retry
    (same with CMUX-manual, just for one channel)
    There's also this mode detection, which should detect what mode the device is.

[michaelboeding]

Thanks for the advice I've been working on switching to the full manual CMUX commands.

1. Will look into that more - seems to only be on new devices so far. So I'll do some more debugging there.
2. I have implemented some new ppp reconnecting logic below - which I think is probably reasonable.

//method used to reconnect PPP after disconnection
esp_modem::command_result BG600L::reconnectPPP() {
    ESP_LOGI(TAG, "Reconnecting PPP...");
    
    // Clear the connect bit first
    xEventGroupClearBits(event_group, CONNECT_BIT);

    // Try to detect what mode the device is in
    esp_modem::command_result sync_result = this->dce->sync();
    if (sync_result != esp_modem::command_result::OK) {
        ESP_LOGI(TAG, "Sync failed, modem might be stuck in data mode");
        
        // Try to switch to command mode
        if (!this->dce->set_mode(esp_modem::modem_mode::CMUX_MANUAL_COMMAND)) {
            ESP_LOGE(TAG, "Failed to switch to CMUX manual command mode");
            // If we can't switch, we might need to exit and re-enter CMUX
            ESP_LOGI(TAG, "Attempting to exit and re-enter CMUX mode");
            
            // Exit CMUX completely
            if (!this->dce->set_mode(esp_modem::modem_mode::CMUX_MANUAL_EXIT)) {
                ESP_LOGE(TAG, "Failed to exit CMUX mode");
                return esp_modem::command_result::FAIL;
            }
            
            vTaskDelay(pdMS_TO_TICKS(500));
            
            // Re-enter CMUX manual mode
            if (!this->dce->set_mode(esp_modem::modem_mode::CMUX_MANUAL_MODE)) {
                ESP_LOGE(TAG, "Failed to re-enter CMUX manual mode");
                return esp_modem::command_result::FAIL;
            }
            
            // Set to command mode
            if (!this->dce->set_mode(esp_modem::modem_mode::CMUX_MANUAL_COMMAND)) {
                ESP_LOGE(TAG, "Failed to set command mode after re-entering CMUX");
                return esp_modem::command_result::FAIL;
            }
        }
        
        // Retry sync up to 3 times
        for (int i = 0; i < 3; ++i) {
            sync_result = this->dce->sync();
            if (sync_result == esp_modem::command_result::OK) {
                ESP_LOGI(TAG, "Sync successful after %d retries", i + 1);
                break;
            }
            vTaskDelay(pdMS_TO_TICKS(1000));
        }
        
        if (sync_result != esp_modem::command_result::OK) {
            ESP_LOGE(TAG, "Failed to sync after retries");
            return esp_modem::command_result::FAIL;
        }
    }

    ESP_LOGI(TAG, "In command mode, performing manual hang-up");
    
    // Manual hang-up before reconnecting (as recommended)
    std::string response;
    if (this->dce->at("ATH", response, 2000) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to execute ATH command");
        return esp_modem::command_result::FAIL;
    }
    ESP_LOGI(TAG, "PPP connection hung up");

    // Flush old PPP PCB so LWIP starts clean
    esp_modem::command_result flush_res = this->dce->pause_netif(true, true, 1000);
    if (flush_res != esp_modem::command_result::OK) {
        ESP_LOGW(TAG, "pause_netif flush returned %d (continuing)", static_cast<int>(flush_res));
    }
    vTaskDelay(pdMS_TO_TICKS(200));

    vTaskDelay(pdMS_TO_TICKS(250));

    // Check signal quality before attempting reconnection
    int rssi, ber;
    if (this->dce->get_signal_quality(rssi, ber) == esp_modem::command_result::OK) {
        ESP_LOGI(TAG, "Signal quality: rssi=%d, ber=%d", rssi, ber);
        if (rssi == 99) { // 99 means no signal
            ESP_LOGE(TAG, "No signal detected, cannot reconnect PPP");
            return esp_modem::command_result::FAIL;
        }
    }

    // First check if we're still registered
    if (waitForNetworkRegistration(30) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Lost network registration during PPP reconnect");
        return esp_modem::command_result::FAIL;
    }
    
    // Check PS attachment
    if (isPsAttached() != esp_modem::command_result::OK) {
        ESP_LOGI(TAG, "PS not attached, waiting...");
        if (waitForPsAttach(30) != esp_modem::command_result::OK) {
            ESP_LOGE(TAG, "PS attach failed during PPP reconnect");
            return esp_modem::command_result::FAIL;
        }
    }
    
    // Now switch to data mode to restart PPP
    if (!this->dce->set_mode(esp_modem::modem_mode::CMUX_MANUAL_DATA)) {
        ESP_LOGE(TAG, "Failed to switch to CMUX manual data mode");
        return esp_modem::command_result::FAIL;
    }
    
    ESP_LOGI(TAG, "Switched to data mode, waiting for PPP to come up");
    
    // Wait for PPP to come up with IP
    if (waitForPppIp(30) != esp_modem::command_result::OK) {
        ESP_LOGE(TAG, "Failed to get IP after PPP reconnect");
        return esp_modem::command_result::FAIL;
    }
    
    ESP_LOGI(TAG, "PPP reconnected successfully");
    return esp_modem::command_result::OK;
}

//method used to reconnect PPP with retry logic
esp_modem::command_result BG600L::reconnectPPPWithRetry(int max_retries, uint32_t backoff_ms) {
    ESP_LOGI(TAG, "Starting PPP reconnection with retry (max_retries=%d, backoff=%ums)", max_retries, backoff_ms);
    
    int retry_count = 0;
    uint32_t current_backoff = backoff_ms;
    
    while (retry_count < max_retries) {
        ESP_LOGI(TAG, "PPP reconnection attempt %d/%d", retry_count + 1, max_retries);
        
        // Try to reconnect
        esp_modem::command_result result = reconnectPPP();
        
        if (result == esp_modem::command_result::OK) {
            ESP_LOGI(TAG, "PPP reconnection successful after %d attempts", retry_count + 1);
            return esp_modem::command_result::OK;
        }
        
        retry_count++;
        
        if (retry_count < max_retries) {
            ESP_LOGI(TAG, "PPP reconnection failed, waiting %ums before retry...", current_backoff);
            vTaskDelay(pdMS_TO_TICKS(current_backoff));
            
            // Exponential backoff with cap at 60 seconds
            current_backoff = (current_backoff * 2 > 60000) ? 60000 : current_backoff * 2;
        }
    }
    
    ESP_LOGE(TAG, "Failed to reconnect PPP after %d attempts", max_retries);
    return esp_modem::command_result::FAIL;
}

3. When you say it needs to handle disconnection you mean the PPP connection right? The eep-modem code will continue to try and connect to register to a network correct?

Thanks