RE: nRF54L15DK: small BLE app and system stalls after phone reconnect (LED heartbeat + shell stop, no reset)

Kenneth — Wed, 07 Jan 2026 13:24:21 GMT
Sounds good! closing case.
Kenneth
RE: nRF54L15DK: small BLE app and system stalls after phone reconnect (LED heartbeat + shell stop, no reset)

jvermillard — Wed, 07 Jan 2026 11:42:51 GMT
after more testing and moving the advertising restart out of the disconnect callback, it works on 3.2.0 (not on zephyr master, but I'll open an issue there)
RE: nRF54L15DK: small BLE app and system stalls after phone reconnect (LED heartbeat + shell stop, no reset)

jvermillard — Wed, 07 Jan 2026 10:35:17 GMT
I simplifyied the code and it's still freezing:
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>

#include <zephyr/drivers/hwinfo.h>
#include <zephyr/settings/settings.h>

#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>

LOG_MODULE_REGISTER(app, CONFIG_LOG_DEFAULT_LEVEL);

static void log_reset_cause(void)
{
#if IS_ENABLED(CONFIG_HWINFO)
        static const struct {
                uint32_t bit;
                const char *name;
        } causes[] = {
                { RESET_PIN, "pin" },
                { RESET_SOFTWARE, "software" },
                { RESET_BROWNOUT, "brownout" },
                { RESET_POR, "power-on" },
                { RESET_WATCHDOG, "watchdog" },
                { RESET_DEBUG, "debug" },
                { RESET_SECURITY, "security" },
                { RESET_LOW_POWER_WAKE, "low-power-wake" },
                { RESET_CPU_LOCKUP, "cpu-lockup" },
                { RESET_PARITY, "parity" },
                { RESET_PLL, "pll" },
                { RESET_CLOCK, "clock" },
                { RESET_HARDWARE, "hardware" },
                { RESET_USER, "user" },
                { RESET_TEMPERATURE, "temperature" },
                { RESET_BOOTLOADER, "bootloader" },
                { RESET_FLASH, "flash" },
        };
        uint32_t supported = 0U;
        uint32_t cause = 0U;
        int err;

        err = hwinfo_get_supported_reset_cause(&supported);
        if (err == 0) {
                LOG_INF("Reset causes supported: 0x%08x", supported);
        }

        err = hwinfo_get_reset_cause(&cause);
        if (err == 0) {
                LOG_INF("Reset cause: 0x%08x", cause);
                for (size_t i = 0; i < ARRAY_SIZE(causes); i++) {
                        if ((cause & causes[i].bit) != 0U) {
                                LOG_INF("Reset cause flag: %s", causes[i].name);
                        }
                }
        } else {
                LOG_WRN("Reset cause unavailable (err %d)", err);
        }

        err = hwinfo_clear_reset_cause();
        if (err) {
                LOG_WRN("Reset cause clear failed (err %d)", err);
        }
#else
        LOG_INF("Reset cause: HWINFO disabled");
#endif
}

static struct bt_conn *default_conn;
struct bond_state {
        int count;
};

static void bond_check(const struct bt_bond_info *info, void *user_data)
{
        struct bond_state *state = user_data;
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(&info->addr, addr, sizeof(addr));
        LOG_INF("Bonded device: %s", addr);
        state->count++;
}

static void update_paired_from_bonds(void)
{
        struct bond_state state = { 0 };

        bt_foreach_bond(BT_ID_DEFAULT, bond_check, &state);
        LOG_INF("Bond count: %d", state.count);
}

static const struct bt_data ad[] = {
        BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
};

static const struct bt_data sd[] = {
        BT_DATA(BT_DATA_NAME_COMPLETE, CONFIG_BT_DEVICE_NAME, sizeof(CONFIG_BT_DEVICE_NAME) - 1),
};

void mtu_updated(struct bt_conn *conn, uint16_t tx, uint16_t rx)
{
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
        LOG_INF("MTU updated for %s: TX %u RX %u", addr, tx, rx);
}

static struct bt_gatt_cb gatt_callbacks = {
        .att_mtu_updated = mtu_updated
};

static void connected(struct bt_conn *conn, uint8_t err)
{
        char addr[BT_ADDR_LE_STR_LEN];
        int sec_err;

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
        if (err) {
                LOG_WRN("Connection failed (%s): err 0x%02x %s",
                        addr, err, bt_hci_err_to_str(err));
        } else {
                LOG_INF("Connected: %s", addr);
                if (default_conn) {
                        bt_conn_unref(default_conn);
                }
                default_conn = bt_conn_ref(conn);
                sec_err = bt_conn_set_security(conn, BT_SECURITY_L2);
                if (sec_err) {
                        LOG_WRN("Failed to set security (err %d)", sec_err);
                }
        }
}

static void disconnected(struct bt_conn *conn, uint8_t reason)
{
        char addr[BT_ADDR_LE_STR_LEN];
        int err;

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
        LOG_INF("Disconnected: %s reason 0x%02x %s",
                addr, reason, bt_hci_err_to_str(reason));

        if (default_conn) {
                bt_conn_unref(default_conn);
                default_conn = NULL;
        }

        LOG_INF("Restarting advertising");
        err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad),
                              sd, ARRAY_SIZE(sd));
        if (err && err != -EALREADY) {
                LOG_ERR("Advertising restart failed (err %d)", err);
        } else {
                LOG_INF("Advertising started");
        }
}

static void security_changed(struct bt_conn *conn, bt_security_t level,
                             enum bt_security_err err)
{
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
        if (err) {
                LOG_WRN("Security failed (%s): level %u err %u", addr, level, err);
        } else {
                LOG_INF("Security changed (%s): level %u", addr, level);
        }
}

static void le_param_updated(struct bt_conn *conn, uint16_t interval,
                             uint16_t latency, uint16_t timeout)
{
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
        LOG_INF("Conn params (%s): interval %u latency %u timeout %u",
                addr, interval, latency, timeout);
}

BT_CONN_CB_DEFINE(conn_callbacks) = {
        .connected = connected,
        .disconnected = disconnected,
        .security_changed = security_changed,
        .le_param_updated = le_param_updated,
};

static void bt_ready(void)
{
        int err;

        LOG_INF("Bluetooth initialized");

        if (IS_ENABLED(CONFIG_SETTINGS)) {
                err = settings_load();
                if (err) {
                        LOG_WRN("Settings load failed (err %d)", err);
                } else {
                        LOG_INF("Settings loaded");
                }
                update_paired_from_bonds();
        }

        LOG_INF("Starting advertising");
        err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), sd, ARRAY_SIZE(sd));
        if (err) {
                LOG_ERR("Advertising failed to start (err %d)", err);
                return;
        }

        LOG_INF("Advertising started");
}

static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
{
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

        LOG_INF("Passkey for %s: %06u", addr, passkey);
}

static void auth_cancel(struct bt_conn *conn)
{
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

        LOG_WRN("Pairing cancelled: %s", addr);
}

static struct bt_conn_auth_cb auth_cb_display = {
        .passkey_display = auth_passkey_display,
        .passkey_entry = NULL,
        .cancel = auth_cancel,
};

static void pairing_complete(struct bt_conn *conn, bool bonded)
{
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
        LOG_INF("Pairing complete: %s bonded=%u", addr, bonded ? 1U : 0U);
}

static void pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
{
        char addr[BT_ADDR_LE_STR_LEN];

        bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
        LOG_WRN("Pairing failed: %s (reason %d)", addr, reason);
}

static struct bt_conn_auth_info_cb auth_info_cb = {
        .pairing_complete = pairing_complete,
        .pairing_failed = pairing_failed,
};

int main(void)
{
        int err;

        LOG_INF("App start");
        log_reset_cause();
        err = bt_enable(NULL);
        if (err) {
                LOG_ERR("Bluetooth init failed (err %d)", err);
                return 0;
        }

        err = bt_passkey_set(123456);
        if (err) {
                LOG_WRN("Failed to set fixed passkey (err %d)", err);
        }

        bt_conn_auth_cb_register(&auth_cb_display);
        bt_conn_auth_info_cb_register(&auth_info_cb);

        bt_ready();
        bt_gatt_cb_register(&gatt_callbacks);

        /* Implement notification. At the moment there is no suitable way
         * of starting delayed work so we do it here
         */
        while (1) {
                k_sleep(K_SECONDS(1));

                if (default_conn && bt_conn_get_security(default_conn) >= BT_SECURITY_L2) {
                }
        }
        return 0;
}