nRF54L15 Zephry Flash init error -22

RE: nRF54L15 Zephry Flash init error -22

AHaug — Thu, 27 Feb 2025 10:26:05 GMT

Ah, you're using 2.8.0. The bug in the peripheral_lbs sample is only present in 2.9.0 so you're good.

Have you seen https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/app_dev/device_guides/nrf54l/zms.html and the two options there to set zms through the settings subsystem?

Kind regards,
Andreas

RE: nRF54L15 Zephry Flash init error -22

Joey Wang — Thu, 27 Feb 2025 02:12:28 GMT

Hi AHaug

I check my project's Kconfig setting, it seems already match the solution(Attached the Kconfig code ).

But I still got the same error. Did I miss something ?Thanks.

My SDK Version is:2.8.0

#
# Copyright (c) 2018 Nordic Semiconductor
#
# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
#

source "Kconfig.zephyr"

menu "Nordic UART BLE GATT service sample"

config BT_NUS_THREAD_STACK_SIZE
	int "Thread stack size"
	default 1024
	help
	  Stack size used in each of the two threads

config BT_NUS_UART_BUFFER_SIZE
	int "UART payload buffer element size"
	default 40
	help
	  Size of the payload buffer in each RX and TX FIFO element

config BT_NUS_SECURITY_ENABLED
	bool "Enable security"
	default y
	select BT_SMP
	help
	  "Enable BLE security for the UART service"

config BT_NUS_UART_RX_WAIT_TIME
	int "Timeout for UART RX complete event"
	default 50000
	help
	  Wait for RX complete event time in microseconds

config SETTINGS
	default y

config ZMS
	default y if SOC_FLASH_NRF_RRAM

config NVS
	default y if !SOC_FLASH_NRF_RRAM

endmenu

Below is the prj.conf

#
# Copyright (c) 2018 Nordic Semiconductor
#
# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
#

#flash enable setting
# Eable NVS 

CONFIG_ZMS=y #zms enable
#CONFIG_SETTINGS_NVS=n
#CONFIG_SETTINGS_FCB=n
#PM_SETTINGS_STORAGE_ID=n

# Enable the UART driver
CONFIG_UART_ASYNC_API=y
CONFIG_NRFX_UARTE0=y
CONFIG_SERIAL=y

CONFIG_GPIO=y

# Make sure printk is printing to the UART console
CONFIG_CONSOLE=y
CONFIG_UART_CONSOLE=y

CONFIG_HEAP_MEM_POOL_SIZE=2048

CONFIG_BT=y
CONFIG_BT_PERIPHERAL=y
CONFIG_BT_DEVICE_NAME="Nordic_UART_Service"
CONFIG_BT_MAX_CONN=1
CONFIG_BT_MAX_PAIRED=1

# Enable the NUS service
CONFIG_BT_NUS=y

# Enable bonding
CONFIG_BT_SETTINGS=y
CONFIG_FLASH=y
CONFIG_FLASH_PAGE_LAYOUT=y
CONFIG_FLASH_MAP=y
#CONFIG_MPU_ALLOW_FLASH_WRITE=y
# Enable DK LED and Buttons library
CONFIG_DK_LIBRARY=y

# This example requires more stack
CONFIG_MAIN_STACK_SIZE=1152
CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048

# Config logger
CONFIG_LOG=y
CONFIG_USE_SEGGER_RTT=y
CONFIG_LOG_BACKEND_RTT=y
CONFIG_LOG_BACKEND_UART=n
CONFIG_LOG_PRINTK=n

CONFIG_ASSERT=y


#CONFIG_NRFX_SYSTICK_ENABLED=y
CONFIG_TIMER=y

RE: nRF54L15 Zephry Flash init error -22

AHaug — Tue, 25 Feb 2025 13:05:36 GMT

Hi,

Good news. I found the reason for why you get both a NVS settings partition and NVS settings partition.

In https://github.com/nrfconnect/sdk-nrf/blob/v2.9.0/samples/bluetooth/peripheral_uart/Kconfig it defaults to both NVS and ZMS, while it should be set as shown in https://github.com/nrfconnect/sdk-nrf/blob/v2.9.0/samples/bluetooth/central_uart/Kconfig (and any other BLE sample).

I.e change

config ZMS
	default y if !(SOC_FLASH_NRF_RRAM || SOC_FLASH_NRF_MRAM)

config NVS
	default y if !(SOC_FLASH_NRF_RRAM || SOC_FLASH_NRF_MRAM)

config ZMS
	default y if (SOC_FLASH_NRF_RRAM || SOC_FLASH_NRF_MRAM)

config NVS
	default y if !(SOC_FLASH_NRF_RRAM || SOC_FLASH_NRF_MRAM)

and it should work with ZMS only.

In case you want to use both ZMS and NVS settings, it might be possible, but for now the suggestion above should fix the issue you're seeing. I will make a bug report to fix it. Edit: The fix is already in sdk-nrf main and will be there from NCS v3.0.0 for the sample this affects

Kind regards,
Andreas

RE: nRF54L15 Zephry Flash init error -22

Joey Wang — Mon, 24 Feb 2025 06:29:10 GMT

Hi AHaug/ Emil,

Thanks for the advice. I’ve changed the setting to ZMS now.

I’m still encountering the same problem in BLE_UART, but ZMS initializes successfully when using the non-BLE blinky sample.

As you mentioned, this might be a flash map issue.

The only difference I found is in the flash_map_pm.h settings:

BLE_UART: settings_storage (RED) → Init failed, fs.offset = 0x163000
Blinky: zms_storage (Green) → Init OK, fs.offset = 0x15F000

It seems no more setting value can check in "flash_map_pm.h",
Only can change the setting "CONFIG_ZMS=y" in prj.conf

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */

/** @file
 *  @brief Nordic UART Bridge Service (NUS) sample
 */
#include <uart_async_adapter.h>

#include <zephyr/types.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/usb/usb_device.h>

#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <soc.h>

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

#include <bluetooth/services/nus.h>

#include <dk_buttons_and_leds.h>

#include <zephyr/settings/settings.h>

#include <stdio.h>
#include <string.h>

#include <zephyr/logging/log.h>

#define LOG_MODULE_NAME peripheral_uart
LOG_MODULE_REGISTER(LOG_MODULE_NAME);

#define STACKSIZE CONFIG_BT_NUS_THREAD_STACK_SIZE
#define PRIORITY 7

#define DEVICE_NAME CONFIG_BT_DEVICE_NAME
#define DEVICE_NAME_LEN	(sizeof(DEVICE_NAME) - 1)

#define RUN_STATUS_LED DK_LED1
#define RUN_LED_BLINK_INTERVAL 1000

#define CON_STATUS_LED DK_LED2

#define KEY_PASSKEY_ACCEPT DK_BTN1_MSK
#define KEY_PASSKEY_REJECT DK_BTN2_MSK

#define UART_BUF_SIZE CONFIG_BT_NUS_UART_BUFFER_SIZE
#define UART_WAIT_FOR_BUF_DELAY K_MSEC(50)
#define UART_WAIT_FOR_RX CONFIG_BT_NUS_UART_RX_WAIT_TIME

static K_SEM_DEFINE(ble_init_ok, 0, 1);

static struct bt_conn *current_conn;
static struct bt_conn *auth_conn;

static const struct device *uart = DEVICE_DT_GET(DT_CHOSEN(nordic_nus_uart));
static struct k_work_delayable uart_work;

struct uart_data_t {
	void *fifo_reserved;
	uint8_t data[UART_BUF_SIZE];
	uint16_t len;
};

static K_FIFO_DEFINE(fifo_uart_tx_data);
static K_FIFO_DEFINE(fifo_uart_rx_data);

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

static const struct bt_data sd[] = {
	BT_DATA_BYTES(BT_DATA_UUID128_ALL, BT_UUID_NUS_VAL),
};

#ifdef CONFIG_UART_ASYNC_ADAPTER
UART_ASYNC_ADAPTER_INST_DEFINE(async_adapter);
#else
#define async_adapter NULL
#endif

static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
{
	ARG_UNUSED(dev);

	static size_t aborted_len;
	struct uart_data_t *buf;
	static uint8_t *aborted_buf;
	static bool disable_req;

	switch (evt->type) {
	case UART_TX_DONE:
		LOG_DBG("UART_TX_DONE");
		if ((evt->data.tx.len == 0) ||
		    (!evt->data.tx.buf)) {
			return;
		}

		if (aborted_buf) {
			buf = CONTAINER_OF(aborted_buf, struct uart_data_t,
					   data[0]);
			aborted_buf = NULL;
			aborted_len = 0;
		} else {
			buf = CONTAINER_OF(evt->data.tx.buf, struct uart_data_t,
					   data[0]);
		}

		k_free(buf);

		buf = k_fifo_get(&fifo_uart_tx_data, K_NO_WAIT);
		if (!buf) {
			return;
		}

		if (uart_tx(uart, buf->data, buf->len, SYS_FOREVER_MS)) {
			LOG_WRN("Failed to send data over UART");
		}

		break;

	case UART_RX_RDY:
		LOG_DBG("UART_RX_RDY");
		buf = CONTAINER_OF(evt->data.rx.buf, struct uart_data_t, data[0]);
		buf->len += evt->data.rx.len;

		if (disable_req) {
			return;
		}

		if ((evt->data.rx.buf[buf->len - 1] == '\n') ||
		    (evt->data.rx.buf[buf->len - 1] == '\r')) {
			disable_req = true;
			uart_rx_disable(uart);
		}

		break;

	case UART_RX_DISABLED:
		LOG_DBG("UART_RX_DISABLED");
		disable_req = false;

		buf = k_malloc(sizeof(*buf));
		if (buf) {
			buf->len = 0;
		} else {
			LOG_WRN("Not able to allocate UART receive buffer");
			k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
			return;
		}

		uart_rx_enable(uart, buf->data, sizeof(buf->data),
			       UART_WAIT_FOR_RX);

		break;

	case UART_RX_BUF_REQUEST:
		LOG_DBG("UART_RX_BUF_REQUEST");
		buf = k_malloc(sizeof(*buf));
		if (buf) {
			buf->len = 0;
			uart_rx_buf_rsp(uart, buf->data, sizeof(buf->data));
		} else {
			LOG_WRN("Not able to allocate UART receive buffer");
		}

		break;

	case UART_RX_BUF_RELEASED:
		LOG_DBG("UART_RX_BUF_RELEASED");
		buf = CONTAINER_OF(evt->data.rx_buf.buf, struct uart_data_t,
				   data[0]);

		if (buf->len > 0) {
			k_fifo_put(&fifo_uart_rx_data, buf);
		} else {
			k_free(buf);
		}

		break;

	case UART_TX_ABORTED:
		LOG_DBG("UART_TX_ABORTED");
		if (!aborted_buf) {
			aborted_buf = (uint8_t *)evt->data.tx.buf;
		}

		aborted_len += evt->data.tx.len;
		buf = CONTAINER_OF((void *)aborted_buf, struct uart_data_t,
				   data);

		uart_tx(uart, &buf->data[aborted_len],
			buf->len - aborted_len, SYS_FOREVER_MS);

		break;

	default:
		break;
	}
}

static void uart_work_handler(struct k_work *item)
{
	struct uart_data_t *buf;

	buf = k_malloc(sizeof(*buf));
	if (buf) {
		buf->len = 0;
	} else {
		LOG_WRN("Not able to allocate UART receive buffer");
		k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
		return;
	}

	uart_rx_enable(uart, buf->data, sizeof(buf->data), UART_WAIT_FOR_RX);
}

static bool uart_test_async_api(const struct device *dev)
{
	const struct uart_driver_api *api =
			(const struct uart_driver_api *)dev->api;

	return (api->callback_set != NULL);
}

static int uart_init(void)
{
	int err;
	int pos;
	struct uart_data_t *rx;
	struct uart_data_t *tx;

	if (!device_is_ready(uart)) {
		return -ENODEV;
	}

	if (IS_ENABLED(CONFIG_USB_DEVICE_STACK)) {
		err = usb_enable(NULL);
		if (err && (err != -EALREADY)) {
			LOG_ERR("Failed to enable USB");
			return err;
		}
	}

	rx = k_malloc(sizeof(*rx));
	if (rx) {
		rx->len = 0;
	} else {
		return -ENOMEM;
	}

	k_work_init_delayable(&uart_work, uart_work_handler);


	if (IS_ENABLED(CONFIG_UART_ASYNC_ADAPTER) && !uart_test_async_api(uart)) {
		/* Implement API adapter */
		uart_async_adapter_init(async_adapter, uart);
		uart = async_adapter;
	}

	err = uart_callback_set(uart, uart_cb, NULL);
	if (err) {
		k_free(rx);
		LOG_ERR("Cannot initialize UART callback");
		return err;
	}

	if (IS_ENABLED(CONFIG_UART_LINE_CTRL)) {
		LOG_INF("Wait for DTR");
		while (true) {
			uint32_t dtr = 0;

			uart_line_ctrl_get(uart, UART_LINE_CTRL_DTR, &dtr);
			if (dtr) {
				break;
			}
			/* Give CPU resources to low priority threads. */
			k_sleep(K_MSEC(100));
		}
		LOG_INF("DTR set");
		err = uart_line_ctrl_set(uart, UART_LINE_CTRL_DCD, 1);
		if (err) {
			LOG_WRN("Failed to set DCD, ret code %d", err);
		}
		err = uart_line_ctrl_set(uart, UART_LINE_CTRL_DSR, 1);
		if (err) {
			LOG_WRN("Failed to set DSR, ret code %d", err);
		}
	}

	tx = k_malloc(sizeof(*tx));

	if (tx) {
		pos = snprintf(tx->data, sizeof(tx->data),
			       "Starting Nordic UART service example\r\n");

		if ((pos < 0) || (pos >= sizeof(tx->data))) {
			k_free(rx);
			k_free(tx);
			LOG_ERR("snprintf returned %d", pos);
			return -ENOMEM;
		}

		tx->len = pos;
	} else {
		k_free(rx);
		return -ENOMEM;
	}

	err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
	if (err) {
		k_free(rx);
		k_free(tx);
		LOG_ERR("Cannot display welcome message (err: %d)", err);
		return err;
	}

	err = uart_rx_enable(uart, rx->data, sizeof(rx->data), UART_WAIT_FOR_RX);
	if (err) {
		LOG_ERR("Cannot enable uart reception (err: %d)", err);
		/* Free the rx buffer only because the tx buffer will be handled in the callback */
		k_free(rx);
	}

	return err;
}

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

	if (err) {
		LOG_ERR("Connection failed, err 0x%02x %s", err, bt_hci_err_to_str(err));
		return;
	}

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
	LOG_INF("Connected %s", addr);

	current_conn = bt_conn_ref(conn);

	dk_set_led_on(CON_STATUS_LED);
}

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

	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 (auth_conn) {
		bt_conn_unref(auth_conn);
		auth_conn = NULL;
	}

	if (current_conn) {
		bt_conn_unref(current_conn);
		current_conn = NULL;
		dk_set_led_off(CON_STATUS_LED);
	}
}

#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
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_INF("Security changed: %s level %u", addr, level);
	} else {
		LOG_WRN("Security failed: %s level %u err %d %s", addr, level, err,
			bt_security_err_to_str(err));
	}
}
#endif

BT_CONN_CB_DEFINE(conn_callbacks) = {
	.connected    = connected,
	.disconnected = disconnected,
#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
	.security_changed = security_changed,
#endif
};

#if defined(CONFIG_BT_NUS_SECURITY_ENABLED)
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_passkey_confirm(struct bt_conn *conn, unsigned int passkey)
{
	char addr[BT_ADDR_LE_STR_LEN];

	auth_conn = bt_conn_ref(conn);

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

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

	if (IS_ENABLED(CONFIG_SOC_SERIES_NRF54HX) || IS_ENABLED(CONFIG_SOC_SERIES_NRF54LX)) {
		LOG_INF("Press Button 0 to confirm, Button 1 to reject.");
	} else {
		LOG_INF("Press Button 1 to confirm, Button 2 to reject.");
	}
}


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_INF("Pairing cancelled: %s", addr);
}


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 completed: %s, bonded: %d", addr, bonded);
}


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_INF("Pairing failed conn: %s, reason %d %s", addr, reason,
		bt_security_err_to_str(reason));
}

static struct bt_conn_auth_cb conn_auth_callbacks = {
	.passkey_display = auth_passkey_display,
	.passkey_confirm = auth_passkey_confirm,
	.cancel = auth_cancel,
};

static struct bt_conn_auth_info_cb conn_auth_info_callbacks = {
	.pairing_complete = pairing_complete,
	.pairing_failed = pairing_failed
};
#else
static struct bt_conn_auth_cb conn_auth_callbacks;
static struct bt_conn_auth_info_cb conn_auth_info_callbacks;
#endif

static void bt_receive_cb(struct bt_conn *conn, const uint8_t *const data,
			  uint16_t len)
{
	int err;
	char addr[BT_ADDR_LE_STR_LEN] = {0};

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

	LOG_INF("Received data from: %s", addr);

	for (uint16_t pos = 0; pos != len;) {
		struct uart_data_t *tx = k_malloc(sizeof(*tx));

		if (!tx) {
			LOG_WRN("Not able to allocate UART send data buffer");
			return;
		}

		/* Keep the last byte of TX buffer for potential LF char. */
		size_t tx_data_size = sizeof(tx->data) - 1;

		if ((len - pos) > tx_data_size) {
			tx->len = tx_data_size;
		} else {
			tx->len = (len - pos);
		}

		memcpy(tx->data, &data[pos], tx->len);

		pos += tx->len;

		/* Append the LF character when the CR character triggered
		 * transmission from the peer.
		 */
		if ((pos == len) && (data[len - 1] == '\r')) {
			tx->data[tx->len] = '\n';
			tx->len++;
		}

		err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
		if (err) {
			k_fifo_put(&fifo_uart_tx_data, tx);
		}
	}
}

static struct bt_nus_cb nus_cb = {
	.received = bt_receive_cb,
};

void error(void)
{
	dk_set_leds_state(DK_ALL_LEDS_MSK, DK_NO_LEDS_MSK);

	while (true) {
		/* Spin for ever */
		k_sleep(K_MSEC(1000));
	}
}

#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
static void num_comp_reply(bool accept)
{
	if (accept) {
		bt_conn_auth_passkey_confirm(auth_conn);
		LOG_INF("Numeric Match, conn %p", (void *)auth_conn);
	} else {
		bt_conn_auth_cancel(auth_conn);
		LOG_INF("Numeric Reject, conn %p", (void *)auth_conn);
	}

	bt_conn_unref(auth_conn);
	auth_conn = NULL;
}

void button_changed(uint32_t button_state, uint32_t has_changed)
{
	uint32_t buttons = button_state & has_changed;

	if (auth_conn) {
		if (buttons & KEY_PASSKEY_ACCEPT) {
			num_comp_reply(true);
		}

		if (buttons & KEY_PASSKEY_REJECT) {
			num_comp_reply(false);
		}
	}
}
#endif /* CONFIG_BT_NUS_SECURITY_ENABLED */

static void configure_gpio(void)
{
	int err;

#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
	err = dk_buttons_init(button_changed);
	if (err) {
		LOG_ERR("Cannot init buttons (err: %d)", err);
	}
#endif /* CONFIG_BT_NUS_SECURITY_ENABLED */

	err = dk_leds_init();
	if (err) {
		LOG_ERR("Cannot init LEDs (err: %d)", err);
	}
}


// #define OpenFlash 1
// #if OpenFlash
// #include <zephyr/drivers/flash.h>
// #include <zephyr/storage/flash_map.h>
// #include <zephyr/fs/nvs.h>
// #endif

// #define NVS_PARTITION		 storage_partition
// #define NVS_PARTITION_DEVICE FIXED_PARTITION_DEVICE(NVS_PARTITION)
// #define NVS_PARTITION_OFFSET FIXED_PARTITION_OFFSET(NVS_PARTITION)



// #if OpenFlash
// struct nvs_fs fs;
// static struct flash_pages_info flash_info;
// static int rc;
// #endif
// int ADDRESS_ID=1;
// int init_flash(void)
// {
// 	#if OpenFlash
// 	fs.flash_device = NVS_PARTITION_DEVICE;
// 	if (!device_is_ready(fs.flash_device)) {
// 		LOG_INF("Flash device %s is not ready\n", fs.flash_device->name);
// 		return 0;
// 	}
// 	fs.offset = NVS_PARTITION_OFFSET;
// 	rc = flash_get_page_info_by_offs(fs.flash_device, fs.offset, &flash_info);
// 	LOG_INF("fs.offset= 0x%X",fs.offset);
// 	if (rc) {
// 		LOG_INF("Unable to get page info\n");
// 		return 0;
// 	}
// 	fs.sector_size = flash_info.size;
// 	fs.sector_count = 5U; //要在Flash存幾筆資料
// 	rc = nvs_mount(&fs);
// 	if (rc) {
// 		LOG_INF("Flash Init failed rc %d\n",rc);
// 		return 0;
// 	}
// 	else{


// 	}
// 	#endif
// 	static char buf[16];
// 	/* ADDRESS_ID is used to store an address, lets see if we can
// 	 * read it from flash, since we don't know the size read the
// 	 * maximum possible
// 	 */
// 	rc = nvs_read(&fs, ADDRESS_ID, &buf, sizeof(buf));
// 	if (rc > 0) { /* item was found, show it */
// 		LOG_INF("Id: %d, Address: %s\n", ADDRESS_ID, buf);
// 	} else   {/* item was not found, add it */
// 		strcpy(buf, "192.168.1.1");
// 		LOG_INF("No address found, adding %s at id %d\n", buf,
// 		       ADDRESS_ID);
// 		(void)nvs_write(&fs, ADDRESS_ID, &buf, strlen(buf)+1);
// 	}

// 	return 1;
// }


// int setup_flash()
// {
// 	int err;
// 	/////////// KH Tsai New Add for Flash (Start)
// 	LOG_INF("init_flash");
// 	err = init_flash(); // KH Tsai New Add
// 	if (err == 0) {
// 		LOG_INF("Flash init failed (err %d)\n", err);
// 		return err;
// 	} else {
// 		LOG_INF("Flash init ok (err %d)\n", err);
// 	}
// 	/////////// KH Tsai New Add for Flash (End)
// }


//#include <zephyr/kernel.h>
#include <zephyr/sys/reboot.h>
//#include <zephyr/device.h>
//#include <string.h>
#include <zephyr/drivers/flash.h>
#include <zephyr/storage/flash_map.h>
#include <zephyr/fs/zms.h>

static struct zms_fs fs;

#define ZMS_PARTITION        storage_partition
#define ZMS_PARTITION_DEVICE FIXED_PARTITION_DEVICE(ZMS_PARTITION)
#define ZMS_PARTITION_OFFSET FIXED_PARTITION_OFFSET(ZMS_PARTITION)

#define IP_ADDRESS_ID 1
#define KEY_VALUE_ID  0xbeefdead
#define CNT_ID        2
#define LONG_DATA_ID  3

#define MAX_ITERATIONS   300
#define DELETE_ITERATION 10

static int delete_and_verify_items(struct zms_fs *fs, uint32_t id)
{
	int rc = 0;
	LOG_INF("delete_and_verify_items");
	rc = zms_delete(fs, id);
	if (rc) {
		goto error1;
	}
	rc = zms_get_data_length(fs, id);
	if (rc > 0) {
		goto error2;
	}

	return 0;
error1:
LOG_INF("Error while deleting item rc=%d\n", rc);
	return rc;
error2:
LOG_INF("Error, Delete failed item should not be present\n");
	return -1;
}

static int delete_basic_items(struct zms_fs *fs)
{
	int rc = 0;
	LOG_INF("delete_basic_items");
	rc = delete_and_verify_items(fs, IP_ADDRESS_ID);
	if (rc) {
		LOG_INF("Error while deleting item %x rc=%d\n", IP_ADDRESS_ID, rc);
		return rc;
	}
	rc = delete_and_verify_items(fs, KEY_VALUE_ID);
	if (rc) {
		LOG_INF("Error while deleting item %x rc=%d\n", KEY_VALUE_ID, rc);
		return rc;
	}
	rc = delete_and_verify_items(fs, CNT_ID);
	if (rc) {
		LOG_INF("Error while deleting item %x rc=%d\n", CNT_ID, rc);
		return rc;
	}
	rc = delete_and_verify_items(fs, LONG_DATA_ID);
	if (rc) {
		LOG_INF("Error while deleting item %x rc=%d\n", LONG_DATA_ID, rc);
	}

	return rc;
}

void zms_setting(void )
{

	int rc = 0;
	char buf[16];
	uint8_t key[8] = {0xDE, 0xAD, 0xBE, 0xEF, 0xDE, 0xAD, 0xBE, 0xEF}, longarray[128];
	uint32_t i_cnt = 0U;
	uint32_t i;
	uint32_t id = 0;
	ssize_t free_space = 0;
	struct flash_pages_info info;

	for (int n = 0; n < sizeof(longarray); n++) {
		longarray[n] = n;
	}

	/* define the zms file system by settings with:
	 *	sector_size equal to the pagesize,
	 *	3 sectors
	 *	starting at ZMS_PARTITION_OFFSET
	 */
	fs.flash_device = ZMS_PARTITION_DEVICE;
	if (!device_is_ready(fs.flash_device)) {
		LOG_INF("Storage device %s is not ready\n", fs.flash_device->name);
		return 0;
	}
	fs.offset = ZMS_PARTITION_OFFSET;
	rc = flash_get_page_info_by_offs(fs.flash_device, fs.offset, &info);
	LOG_INF("rc=%d",rc);
	if (rc) {
		LOG_INF("Unable to get page info, rc=%d\n", rc);
		return 0;
	}
	fs.sector_size = info.size;
	fs.sector_count = 3U;
	for (i = 0; i < MAX_ITERATIONS; i++) {
		rc = zms_mount(&fs);
		LOG_INF("fs offset=%x",fs.offset);
		if (rc) {
			LOG_INF("Storage Init failed, rc=%d\n", rc);
			return 0;
		}

		LOG_INF("ITERATION: %u\n", i);
		/* IP_ADDRESS_ID is used to store an address, lets see if we can
		 * read it from flash, since we don't know the size read the
		 * maximum possible
		 */
		rc = zms_read(&fs, IP_ADDRESS_ID, &buf, sizeof(buf));
		if (rc > 0) {
			/* item was found, show it */
			buf[rc] = '\0';
			LOG_INF("ID: %u, IP Address: %s\n", IP_ADDRESS_ID, buf);
		}
		/* Rewriting ADDRESS IP even if we found it */
		strncpy(buf, "172.16.254.1", sizeof(buf) - 1);
		LOG_INF("Adding IP_ADDRESS %s at id %u\n", buf, IP_ADDRESS_ID);
		rc = zms_write(&fs, IP_ADDRESS_ID, &buf, strlen(buf));
		if (rc < 0) {
			LOG_INF("Error while writing Entry rc=%d\n", rc);
			break;
		}

		/* KEY_VALUE_ID is used to store a key/value pair , lets see if we can read
		 * it from storage.
		 */
		rc = zms_read(&fs, KEY_VALUE_ID, &key, sizeof(key));
		if (rc > 0) { /* item was found, show it */
			LOG_INF("Id: %x, Key: ", KEY_VALUE_ID);
			for (uint8_t n = 0; n < 8; n++) {
				LOG_INF("%x ", key[n]);
			}
			LOG_INF("\n");
		}
		/* Rewriting KEY_VALUE even if we found it */
		LOG_INF("Adding key/value at id %x\n", KEY_VALUE_ID);
		rc = zms_write(&fs, KEY_VALUE_ID, &key, sizeof(key));
		if (rc < 0) {
			LOG_INF("Error while writing Entry rc=%d\n", rc);
			break;
		}

		/* CNT_ID is used to store the loop counter, lets see
		 * if we can read it from storage
		 */
		rc = zms_read(&fs, CNT_ID, &i_cnt, sizeof(i_cnt));
		if (rc > 0) { /* item was found, show it */
			LOG_INF("Id: %d, loop_cnt: %u\n", CNT_ID, i_cnt);
			if (i_cnt != (i - 1)) {
				break;
			}
		}
		LOG_INF("Adding counter at id %u\n", CNT_ID);
		rc = zms_write(&fs, CNT_ID, &i, sizeof(i));
		if (rc < 0) {
			LOG_INF("Error while writing Entry rc=%d\n", rc);
			break;
		}

		/* LONG_DATA_ID is used to store a larger dataset ,lets see if we can read
		 * it from flash
		 */
		rc = zms_read(&fs, LONG_DATA_ID, &longarray, sizeof(longarray));
		if (rc > 0) {
			/* item was found, show it */
			LOG_INF("Id: %d, Longarray: ", LONG_DATA_ID);
			for (uint16_t n = 0; n < sizeof(longarray); n++) {
				LOG_INF("%x ", longarray[n]);
			}
			LOG_INF("\n");
		}
		/* Rewrite the entry even if we found it */
		LOG_INF("Adding Longarray at id %d\n", LONG_DATA_ID);
		rc = zms_write(&fs, LONG_DATA_ID, &longarray, sizeof(longarray));
		if (rc < 0) {
			LOG_INF("Error while writing Entry rc=%d\n", rc);
			break;
		}

		/* Each DELETE_ITERATION delete all basic items */
		if (!(i % DELETE_ITERATION) && (i)) {
			rc = delete_basic_items(&fs);
			if (rc) {
				break;
			}
		}
	}

}


int main(void)
{
	int blink_status = 0;
	int err = 0;

	configure_gpio();

	err = uart_init();
	if (err) {
		error();
	}

	if (IS_ENABLED(CONFIG_BT_NUS_SECURITY_ENABLED)) {
		err = bt_conn_auth_cb_register(&conn_auth_callbacks);
		if (err) {
			printk("Failed to register authorization callbacks.\n");
			return 0;
		}

		err = bt_conn_auth_info_cb_register(&conn_auth_info_callbacks);
		if (err) {
			printk("Failed to register authorization info callbacks.\n");
			return 0;
		}
	}

	//setup_flash();
	zms_setting();

	err = bt_enable(NULL);
	if (err) {
		error();
	}

	LOG_INF("Bluetooth initialized");

	k_sem_give(&ble_init_ok);

	if (IS_ENABLED(CONFIG_SETTINGS)) {
		settings_load();
	}

	err = bt_nus_init(&nus_cb);
	if (err) {
		LOG_ERR("Failed to initialize UART service (err: %d)", err);
		return 0;
	}

	err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad), sd,
			      ARRAY_SIZE(sd));
	if (err) {
		LOG_ERR("Advertising failed to start (err %d)", err);
		return 0;
	}

	for (;;) {
		dk_set_led(RUN_STATUS_LED, (++blink_status) % 2);
		k_sleep(K_MSEC(RUN_LED_BLINK_INTERVAL));
	}
}

void ble_write_thread(void)
{
	/* Don't go any further until BLE is initialized */
	k_sem_take(&ble_init_ok, K_FOREVER);
	struct uart_data_t nus_data = {
		.len = 0,
	};

	for (;;) {
		/* Wait indefinitely for data to be sent over bluetooth */
		struct uart_data_t *buf = k_fifo_get(&fifo_uart_rx_data,
						     K_FOREVER);

		int plen = MIN(sizeof(nus_data.data) - nus_data.len, buf->len);
		int loc = 0;

		while (plen > 0) {
			memcpy(&nus_data.data[nus_data.len], &buf->data[loc], plen);
			nus_data.len += plen;
			loc += plen;

			if (nus_data.len >= sizeof(nus_data.data) ||
			   (nus_data.data[nus_data.len - 1] == '\n') ||
			   (nus_data.data[nus_data.len - 1] == '\r')) {
				if (bt_nus_send(NULL, nus_data.data, nus_data.len)) {
					LOG_WRN("Failed to send data over BLE connection");
				}
				nus_data.len = 0;
			}

			plen = MIN(sizeof(nus_data.data), buf->len - loc);
		}

		k_free(buf);
	}
}

K_THREAD_DEFINE(ble_write_thread_id, STACKSIZE, ble_write_thread, NULL, NULL,
		NULL, PRIORITY, 0, 0);

RE: nRF54L15 Zephry Flash init error -22

Emil Lenngren — Thu, 20 Feb 2025 09:13:24 GMT

Thanks for the correction. I updated my reply.

RE: nRF54L15 Zephry Flash init error -22

AHaug — Thu, 20 Feb 2025 07:48:52 GMT

Hi,

That's a very good point, Emil. NVS is compatible with RRAM, but it treats it as flash and introduces a lot more write/swap and general tear on the RRAM. As the link you sent states, ZMS reduces this: " reduces write and erase cycles, extending the lifespan of non-volatile memory."

Kind regards,
Andreas

RE: nRF54L15 Zephry Flash init error -22

Emil Lenngren — Wed, 19 Feb 2025 18:04:55 GMT

Note that nRF54L15 does not have any flash. Instead it has RRAM. NVS is designed for flash and comes with a penalty if you use it for RRAM. You can use ZMS instead as a replacement, see docs.nordicsemi.com/.../zms.html.

RE: nRF54L15 Zephry Flash init error -22

AHaug — Wed, 19 Feb 2025 14:29:52 GMT

Hi,

Just to be sure, are you able to set up a sample without BLE that uses the LittleFS partition on the nRF54L15? Both BLE and the NVS sample sets up a settings partition that it seems to be a conflict with. If you could isolate that you're getting either setups to work, that would be much appreciated.

I would also recommend that you in the future attach code and/or logs as a insert -> code

Kind regards,
Andreas