issue with mcumgr with nrf54l05

[yash23]

# Console disabled - uart30 used exclusively for MCUmgr SMP

CONFIG_SERIAL=y

CONFIG_CONSOLE=y

CONFIG_UART_CONSOLE=y

CONFIG_PRINTK=y

CONFIG_LOG=y

CONFIG_MAIN_STACK_SIZE=8192

#  ENABLE INTERNAL OSCILLATOR

CONFIG_CLOCK_CONTROL_NRF_K32SRC_RC=y

# ENABLE SPI NOR FLASH

CONFIG_SPI=y

CONFIG_FLASH=y

CONFIG_FLASH_MAP=y

CONFIG_SPI_NOR=y

CONFIG_FILE_SYSTEM=y

CONFIG_FILE_SYSTEM_LITTLEFS=y

CONFIG_FILE_SYSTEM_MKFS=y

CONFIG_FS_LITTLEFS_READ_SIZE=4096

CONFIG_FS_LITTLEFS_PROG_SIZE=4096

CONFIG_FS_LITTLEFS_CACHE_SIZE=4096

CONFIG_FS_LITTLEFS_LOOKAHEAD_SIZE=128

CONFIG_PM_PARTITION_REGION_LITTLEFS_EXTERNAL=y

CONFIG_PM_PARTITION_SIZE_LITTLEFS=0x1000000

CONFIG_PM_OVERRIDE_EXTERNAL_DRIVER_CHECK=y

CONFIG_FLASH_PAGE_LAYOUT=y

CONFIG_MCUMGR=y

CONFIG_MCUMGR_TRANSPORT_UART=y

CONFIG_UART_MCUMGR=y

CONFIG_UART_INTERRUPT_DRIVEN=y

CONFIG_MCUMGR_GRP_OS=y

CONFIG_MCUMGR_GRP_FS=y

CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=8192

CONFIG_NET_BUF=y

CONFIG_ZCBOR=y

CONFIG_CRC=y

CONFIG_BASE64=y

CONFIG_MCUMGR_TRANSPORT_NETBUF_SIZE=2048

CONFIG_MCUMGR_TRANSPORT_NETBUF_COUNT=8

CONFIG_MCUMGR_GRP_FS_DL_CHUNK_SIZE=512

#include <flash_map_pm.h>

#include <pm_config.h>

#include <zephyr/fs/fs.h>

#include <zephyr/fs/littlefs.h>

#include <zephyr/kernel.h>

#include <zephyr/sys/printk.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdint.h>

#include <string.h>

#define LOG_LEVEL LOG_LEVEL_DBG

#define LFS_PARTITION_ID PM_littlefs_storage_ID

#define LFS_MOUNT_POINT "/lfs"

#define LFS_HEX_FILE LFS_MOUNT_POINT "/hex30.bin"

#define LFS_BIN_FILE_PREFIX LFS_MOUNT_POINT "/data30000_"

#define LOOP_DELAY_S 5

#define HEX_DATA_LEN 30

#define BIN_DATA_LEN 30000

#define BIN_CHUNK_SIZE 32

#define BIN_SEGMENT_SIZE 960

FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(lfs_cfg);

static struct fs_mount_t lfs_mnt = {

    .type = FS_LITTLEFS,

    .mnt_point = LFS_MOUNT_POINT,

    .fs_data = &lfs_cfg,

    .storage_dev = (void *)LFS_PARTITION_ID,

};

static bool lfs_is_mounted;

static int littlefs_mount_with_format(void)

{

        if (lfs_is_mounted)

        {

                printk("LittleFS already mounted at %s\n", LFS_MOUNT_POINT);

                return 0;

        }

        int ret = fs_mount(&lfs_mnt);

        if (ret == 0)

        {

                lfs_is_mounted = true;

                return 0;

        }

        printk("LittleFS mount failed (%d)\n", ret);

#if defined(CONFIG_FILE_SYSTEM_MKFS) && CONFIG_FILE_SYSTEM_MKFS

        printk("Formatting LittleFS partition and retrying mount...\n");

        ret = fs_mkfs(FS_LITTLEFS, (uintptr_t)lfs_mnt.storage_dev, lfs_mnt.fs_data, 0);

        if (ret != 0)

        {

                printk("LittleFS format failed: %d\n", ret);

                return ret;

        }

        ret = fs_mount(&lfs_mnt);

        if (ret != 0)

        {

                printk("LittleFS mount after format failed: %d\n", ret);

                return ret;

        }

        lfs_is_mounted = true;

        return 0;

#else

        printk("Enable CONFIG_FILE_SYSTEM_MKFS to auto-format on first boot\n");

        return ret;

#endif

}

void read_file(void)

{

        struct fs_file_t file;

        char buf[128]; // small buffer is fine

        fs_file_t_init(&file);

        int ret = fs_open(&file, "/lfs/myfile6.txt", FS_O_READ);

        if (ret < 0)

        {

                printk("Open failed: %d\n", ret);

                return;

        }

        while (1)

        {

                ret = fs_read(&file, buf, sizeof(buf));

                if (ret <= 0)

                {

                        break;

                }

                printk("Bytes read: %d\n", ret);

                for (int i = 2; i < ret; i += 2)

                {

                        printk("%c", buf[i]);

                }

        }

        printk("\n--- END ---\n");

        fs_close(&file);

}

int main(void)

{

        int ret;

        ret = littlefs_mount_with_format();

        if (ret != 0)

        {

                printk("LittleFS mount failed: %d\n", ret);

        }

        else

        {

                printk("LittleFS mounted\n");

        }

        while (1)

        {

                // printk("print test\n");

                read_file(); //  read file every loop

                k_sleep(K_SECONDS(3));

        }

}

/ {

    aliases {

        whiteled = &led0;

        greenled = &led1;

        redled = &led2;

        blueled = &led0;

    };

    chosen {

        nordic,pm-ext-flash = &w25q128;

        zephyr,console = &uart30;

        zephyr,shell-uart = &uart30;

        zephyr,uart-mcumgr = &uart30;

    };

    leds {

        compatible = "gpio-leds";

        led0: led_0 {

            gpios = <&gpio1 7 GPIO_ACTIVE_LOW>; // Change pin as needed

            label = "white-led";

        };

        led1: led_1 {

            gpios = <&gpio0 1 GPIO_ACTIVE_LOW>;

            label = "Green-led";

        };

        led2: led_2 {

            gpios = <&gpio0 4 GPIO_ACTIVE_LOW>;

            label = "Red-led";

        };

    };

};

//enable wdt30

&wdt30 {

    status = "okay";

};

// Pin control configuration for SPI

&pinctrl {

    spi20_default: spi20_default {

        group1 {

            psels = <NRF_PSEL(SPIM_SCK, 1, 12)>,

                    <NRF_PSEL(SPIM_MOSI, 1, 13)>,

                    <NRF_PSEL(SPIM_MISO, 1, 8)>;  // MISO pin

                };

    };

    spi20_sleep: spi20_sleep {

        group1 {

            psels = <NRF_PSEL(SPIM_SCK, 1, 12)>,

                    <NRF_PSEL(SPIM_MOSI, 1, 13)>,

                    <NRF_PSEL(SPIM_MISO, 1, 8)>;

            // low-power-enable;

        };

    };

};

// Enable SPI0 interface

&spi20 {

    status = "okay";

    compatible = "nordic,nrf-spim";

    pinctrl-0 = <&spi20_default>;

    pinctrl-1 = <&spi20_sleep>;

    pinctrl-names = "default", "sleep";

    cs-gpios = <&gpio1 10 GPIO_ACTIVE_LOW>;

    w25q128: w25q128@0 {

        compatible = "jedec,spi-nor";

        status = "okay";

        reg = <0>;

        spi-max-frequency = <8000000>;

        jedec-id = [ef 40 18];

        size = <0x1000000>;

    };

};

&button0 {

    gpios = <&gpio1 2 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>;

};

&wdt30 {

    status = "okay";

};

&button2 {

    gpios = <&gpio1 0 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>;

};

&uart30_sleep {

    group1 {

        psels = <NRF_PSEL(UART_TX, 0, 2)>,

                <NRF_PSEL(UART_RX, 0, 3)>,

                <NRF_PSEL(UART_RTS, 1, 4)>,

                <NRF_PSEL(UART_CTS, 1, 5)>;

    };

};

&uart30_default {

    group2 {

        psels = <NRF_PSEL(UART_RX, 0, 3)>, <NRF_PSEL(UART_CTS, 1, 5)>;

    };

    group1 {

        psels = <NRF_PSEL(UART_TX, 0, 2)>, <NRF_PSEL(UART_RTS, 1, 4)>;

    };

};

// &button3 {

//     gpios = <&gpio0 2 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>;

// };

&button0 {

    gpios = <&gpio1 2 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>;

};

&button1 {

    gpios = <&gpio2 9 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>;

};

&button2 {

    gpios = <&gpio2 8 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>;

};

&uart20 {

    status = "disabled";

};

&uart30 {

    status = "okay";

    current-speed = <115200>;

    pinctrl-0 = <&uart30_default>;

    pinctrl-1 = <&uart30_sleep>;

    pinctrl-names = "default", "sleep";

};

i am trying to upload the file which has almost 3kb data but it is getting failed at around 1k+ or -  this is error PS D:\nrf_projects\little_fs_nrf54l05> newtmgr --conntype serial --connstring "dev=COM5,baud=115200,mtu=120" fs upload myfile.txt /lfs/myfile.txt
28
55
82
109
136
163
190
217
244
271
297
323
349
375
401
427
453
479
505
531
557
583
609
635
661
687
713
739
765
791
817
843
869
895
921
947
973
999
0
Error: 1

[Hung Bui]

Hi Yash, 
Have you tried to follow our guide in the Nordic Devacademy  ? 
https://academy.nordicsemi.com/courses/nrf-connect-sdk-intermediate/lessons/lesson-9-bootloaders-and-dfu-fota/topic/exercise-1-dfu-over-uart/

Have you tried other command such as the newtmgr image list  ? 

I just want to check if the SMP protocol works. 

If you upload a very small image (<1kB) would it work ? Any reason it's a myfile.txt ? Have you simply upload a binary file of an application ?