i am reading the wav file from SD card and playing in I2S but getting This error can anyone Help with this?
I really appreciate any help you can provide.
######## CODE ############
/* * Copyright 2023 NXP * * SPDX-License-Identifier: Apache-2.0 */ #include <zephyr/kernel.h> #include <zephyr/sys/printk.h> #include <zephyr/drivers/i2s.h> #include <zephyr/drivers/gpio.h> #include <string.h> // flash #include <zephyr/storage/disk_access.h> #include <zephyr/fs/fs.h> #include <zephyr/drivers/flash.h> #include <zephyr/storage/flash_map.h> #include <stdio.h> /*################################# FLASH & SD CARD ###########################################*/ #define TEST_PARTITION slot1_partition #define TEST_PARTITION_OFFSET FIXED_PARTITION_OFFSET(TEST_PARTITION) #define TEST_PARTITION_DEVICE FIXED_PARTITION_DEVICE(TEST_PARTITION) #define TEST_PARTITION_SIZE FIXED_PARTITION_SIZE(TEST_PARTITION) // #define FLASH_PAGE_SIZE 4096 #if defined(CONFIG_FAT_FILESYSTEM_ELM) #include <ff.h> /* * Note the fatfs library is able to mount only strings inside _VOLUME_STRS * in ffconf.h */ #define DISK_DRIVE_NAME "SD" #define DISK_MOUNT_PT "/" DISK_DRIVE_NAME ":" static FATFS fat_fs; /* mounting info */ static struct fs_mount_t mp = { .type = FS_FATFS, .fs_data = &fat_fs, }; #elif defined(CONFIG_FILE_SYSTEM_EXT2) #include <zephyr/fs/ext2.h> #define DISK_DRIVE_NAME "SDMMC" #define DISK_MOUNT_PT "/ext" static struct fs_mount_t mp = { .type = FS_EXT2, .flags = FS_MOUNT_FLAG_NO_FORMAT, .storage_dev = (void *)DISK_DRIVE_NAME, .mnt_point = "/ext", }; #endif // LOG_MODULE_REGISTER(main); // #define MAX_PATH 128 // #define SOME_FILE_NAME "some.dat" // #define SOME_DIR_NAME "some" // #define SOME_REQUIRED_LEN MAX(sizeof(SOME_FILE_NAME), sizeof(SOME_DIR_NAME)) static int lsdir(const char *path); #ifdef CONFIG_FS_SAMPLE_CREATE_SOME_ENTRIES static bool create_some_entries(const char *base_path) { char path[MAX_PATH]; struct fs_file_t file; int base = strlen(base_path); fs_file_t_init(&file); if (base >= (sizeof(path) - SOME_REQUIRED_LEN)) { LOG_ERR("Not enough concatenation buffer to create file paths"); return false; } LOG_INF("Creating some dir entries in %s", base_path); strncpy(path, base_path, sizeof(path)); path[base++] = '/'; path[base] = 0; strcat(&path[base], SOME_FILE_NAME); if (fs_open(&file, path, FS_O_CREATE) != 0) { LOG_ERR("Failed to create file %s", path); return false; } fs_close(&file); path[base] = 0; strcat(&path[base], SOME_DIR_NAME); if (fs_mkdir(path) != 0) { LOG_ERR("Failed to create dir %s", path); /* If code gets here, it has at least successes to create the * file so allow function to return true. */ } return true; } #endif static const char *disk_mount_pt = DISK_MOUNT_PT; void sd_card_mount() { // mux_mode(NRF_OTA); // k_msleep(100); // /* raw disk i/o */ do { static const char *disk_pdrv = DISK_DRIVE_NAME; uint64_t memory_size_mb; uint32_t block_count; uint32_t block_size; if (disk_access_init(disk_pdrv) != 0) { printk("Storage init ERROR!"); break; } if (disk_access_ioctl(disk_pdrv, DISK_IOCTL_GET_SECTOR_COUNT, &block_count)) { printk("Unable to get sector count"); break; } printk("Block count %u", block_count); if (disk_access_ioctl(disk_pdrv, DISK_IOCTL_GET_SECTOR_SIZE, &block_size)) { printk("Unable to get sector size"); break; } printk("Sector size %u\n", block_size); memory_size_mb = (uint64_t)block_count * block_size; printk("Memory Size(MB) %u\n", (uint32_t)(memory_size_mb >> 20)); } while (0); mp.mnt_point = disk_mount_pt; int res = fs_mount(&mp); if (res == FR_OK) { printk("Disk mounted.\n"); // lsdir(disk_mount_pt); } else { printk("Error mounting disk.\n"); } // fs_unmount(&mp); } uint8_t buf_word = 0U; uint32_t offset; int write_len = 0; int write_count = 0; struct fs_file_t filep; static int lsdir(const char *path) { const struct device *flash_dev = TEST_PARTITION_DEVICE; int res; struct fs_dir_t dirp; static struct fs_dirent entry; int count = 0; fs_dir_t_init(&dirp); // struct fs_file_t filep; // fs_file_t_init(&filep); struct fs_file_t filep2; fs_file_t_init(&filep2); /* Verify fs_opendir() */ res = fs_opendir(&dirp, path); if (res) { printk("Error opening dir %s [%d]\n", path, res); return res; } printk("\nListing dir %s ...\n", path); for (;;) { /* Verify fs_readdir() */ res = fs_readdir(&dirp, &entry); /* entry.name[0] == 0 means end-of-dir */ if (res || entry.name[0] == 0) { break; } if (entry.type == FS_DIR_ENTRY_DIR) { printk("[DIR ] %s\n", entry.name); } else { printk("[FILE] %s (size = %zu)\n", entry.name, entry.size); // char *file_to_update = "APP_UP~1.BIN"; // if (!strcmp(entry.name, file_to_update)) // { // printk("Transfering to flash \n"); // char fname1[255]; // snprintf(fname1, sizeof(fname1), "%s/%s", mp.mnt_point, file_to_update); // res = fs_open(&filep, fname1, FS_O_READ); // if (res) // { // printk("Error opening file %s [%d]\n", fname1, res); // return res; // } // char fname2[255]; // snprintf(fname2, sizeof(fname2), "%s/VALID.BIN", mp.mnt_point); // fs_unlink(fname2); // res = fs_open(&filep2, fname2, FS_O_CREATE | FS_O_RDWR); // if (res) // { // printk("Error opening file %s [%d]\n", fname2, res); // return res; // } // int filze_size = (uint32_t *)entry.size; // printk("file size: %lu \n", filze_size); // int line_size = 255; // uint8_t line[line_size]; // if (!device_is_ready(flash_dev)) // { // printf("Flash device not ready\n"); // return 0; // } // // printf("\nTest 1: Flash erase page at 0x%x\n", TEST_PARTITION_OFFSET); // if (flash_erase(flash_dev, TEST_PARTITION_OFFSET, TEST_PARTITION_SIZE) != 0) // { // printf(" Flash erase failed!\n"); // } // else // { // // printf(" Flash erase succeeded!\n"); // } // // offset = TEST_PARTITION_OFFSET; // // filze_size = filze_size - line_size; // // Read file contents line by line // printf("read:"); // while ((filze_size > 0)) // { // if (filze_size < line_size) // { // fs_read(&filep, line, filze_size); // write_len = write_count + filze_size; // filze_size = 0; // printk("#Line: %d : %s \n", filze_size, line); // } // else // { // fs_read(&filep, line, line_size); // // Print the line // filze_size = filze_size - line_size; // printk("Line: %d : %s \n", filze_size, line); // write_len = write_count + line_size; // } // int byte_count = 0; // while (write_count < write_len) // { // offset = TEST_PARTITION_OFFSET + write_count; // if (flash_write(flash_dev, offset, &line[byte_count], // sizeof(uint8_t)) != 0) // { // printf(" Flash write failed!\n"); // return 0; // } // if (flash_read(flash_dev, offset, &buf_word, // sizeof(uint8_t)) != 0) // { // printf(" Flash read failed!\n"); // return 0; // } // printf("%c", buf_word); // fs_seek(&filep2, 0, FS_SEEK_END); // fs_write(&filep2, &buf_word, sizeof(uint8_t)); // if (line[byte_count] == buf_word) // { // // printf(" Data read matches data written. Good!\n"); // } // else // { // printf(" Data read does not match data written!\n"); // } // write_count++; // byte_count++; // // printk("WRITE COUNT: %d \n", write_count); // } // // printk("WRITE COUNT: %d \n", write_count); // } // printf("\n"); // fs_close(&filep); // fs_close(&filep2); // printk("END \n"); // boot_request_upgrade(0); // sys_reboot(0); // } } count++; } /* Verify fs_closedir() */ fs_closedir(&dirp); if (res == 0) { res = count; } return res; } /*##################################################################################################### */ #if DT_NODE_EXISTS(DT_NODELABEL(i2s_rxtx)) #define I2S_RX_NODE DT_NODELABEL(i2s_rxtx) #define I2S_TX_NODE I2S_RX_NODE #else #define I2S_RX_NODE DT_NODELABEL(i2s_rx) #define I2S_TX_NODE DT_NODELABEL(i2s_tx) #endif #define SAMPLE_FREQUENCY 44100 #define SAMPLE_BIT_WIDTH 16 #define BYTES_PER_SAMPLE sizeof(int16_t) #define NUMBER_OF_CHANNELS 1 /* Such block length provides an echo with the delay of 100 ms. */ #define SAMPLES_PER_BLOCK ((SAMPLE_FREQUENCY / 10) * NUMBER_OF_CHANNELS) #define INITIAL_BLOCKS 2 #define TIMEOUT 5000 #define SW0_NODE DT_ALIAS(sw0) #if DT_NODE_HAS_STATUS(SW0_NODE, okay) static struct gpio_dt_spec sw0_spec = GPIO_DT_SPEC_GET(SW0_NODE, gpios); #endif #define SW1_NODE DT_ALIAS(sw1) #if DT_NODE_HAS_STATUS(SW1_NODE, okay) static struct gpio_dt_spec sw1_spec = GPIO_DT_SPEC_GET(SW1_NODE, gpios); #endif #define BLOCK_SIZE (BYTES_PER_SAMPLE * SAMPLES_PER_BLOCK) #define BLOCK_COUNT (INITIAL_BLOCKS + 2) K_MEM_SLAB_DEFINE_STATIC(mem_slab, BLOCK_SIZE, BLOCK_COUNT, 4); static int16_t echo_block[SAMPLES_PER_BLOCK]; static volatile bool echo_enabled = true; static K_SEM_DEFINE(toggle_transfer, 1, 1); #if DT_NODE_HAS_STATUS(SW0_NODE, okay) static void sw0_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins) { bool enable = !echo_enabled; echo_enabled = enable; printk("Echo %sabled\n", (enable ? "en" : "dis")); } #endif #if DT_NODE_HAS_STATUS(SW1_NODE, okay) static void sw1_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins) { k_sem_give(&toggle_transfer); } #endif static bool init_buttons(void) { int ret; #if DT_NODE_HAS_STATUS(SW0_NODE, okay) static struct gpio_callback sw0_cb_data; if (!gpio_is_ready_dt(&sw0_spec)) { printk("%s is not ready\n", sw0_spec.port->name); return false; } ret = gpio_pin_configure_dt(&sw0_spec, GPIO_INPUT); if (ret < 0) { printk("Failed to configure %s pin %d: %d\n", sw0_spec.port->name, sw0_spec.pin, ret); return false; } ret = gpio_pin_interrupt_configure_dt(&sw0_spec, GPIO_INT_EDGE_TO_ACTIVE); if (ret < 0) { printk("Failed to configure interrupt on %s pin %d: %d\n", sw0_spec.port->name, sw0_spec.pin, ret); return false; } gpio_init_callback(&sw0_cb_data, sw0_handler, BIT(sw0_spec.pin)); gpio_add_callback(sw0_spec.port, &sw0_cb_data); printk("Press \"%s\" to toggle the echo effect\n", sw0_spec.port->name); #endif #if DT_NODE_HAS_STATUS(SW1_NODE, okay) static struct gpio_callback sw1_cb_data; if (!gpio_is_ready_dt(&sw1_spec)) { printk("%s is not ready\n", sw1_spec.port->name); return false; } ret = gpio_pin_configure_dt(&sw1_spec, GPIO_INPUT); if (ret < 0) { printk("Failed to configure %s pin %d: %d\n", sw1_spec.port->name, sw1_spec.pin, ret); return false; } ret = gpio_pin_interrupt_configure_dt(&sw1_spec, GPIO_INT_EDGE_TO_ACTIVE); if (ret < 0) { printk("Failed to configure interrupt on %s pin %d: %d\n", sw1_spec.port->name, sw1_spec.pin, ret); return false; } gpio_init_callback(&sw1_cb_data, sw1_handler, BIT(sw1_spec.pin)); gpio_add_callback(sw1_spec.port, &sw1_cb_data); printk("Press \"%s\" to stop/restart I2S streams\n", sw1_spec.port->name); #endif (void)ret; return true; } static void process_block_data(void *mem_block, uint32_t number_of_samples) { static bool clear_echo_block; if (echo_enabled) { for (int i = 0; i < number_of_samples; ++i) { int16_t *sample = &((int16_t *)mem_block)[i]; *sample += echo_block[i]; echo_block[i] = (*sample) / 2; } clear_echo_block = true; } else if (clear_echo_block) { clear_echo_block = false; memset(echo_block, 0, sizeof(echo_block)); } } static bool configure_streams(const struct device *i2s_dev_rx, const struct device *i2s_dev_tx, const struct i2s_config *config) { int ret; if (i2s_dev_rx == i2s_dev_tx) { ret = i2s_configure(i2s_dev_rx, I2S_DIR_BOTH, config); if (ret == 0) { return true; } /* -ENOSYS means that the RX and TX streams need to be * configured separately. */ if (ret != -ENOSYS) { printk("Failed to configure streams: %d\n", ret); return false; } } ret = i2s_configure(i2s_dev_rx, I2S_DIR_RX, config); if (ret < 0) { printk("Failed to configure RX stream: %d\n", ret); return false; } ret = i2s_configure(i2s_dev_tx, I2S_DIR_TX, config); if (ret < 0) { printk("Failed to configure TX stream: %d\n", ret); return false; } return true; } static bool prepare_transfer(const struct device *i2s_dev_rx, const struct device *i2s_dev_tx) { int ret; for (int i = 0; i < INITIAL_BLOCKS; ++i) { void *mem_block; ret = k_mem_slab_alloc(&mem_slab, &mem_block, K_NO_WAIT); if (ret < 0) { printk("Failed to allocate TX block %d: %d\n", i, ret); return false; } memset(mem_block, 0, BLOCK_SIZE); ret = i2s_write(i2s_dev_tx, mem_block, BLOCK_SIZE); if (ret < 0) { printk("Failed to write block %d: %d\n", i, ret); return false; } } return true; } static bool trigger_command(const struct device *i2s_dev_rx, const struct device *i2s_dev_tx, enum i2s_trigger_cmd cmd) { int ret; if (i2s_dev_rx == i2s_dev_tx) { ret = i2s_trigger(i2s_dev_rx, I2S_DIR_BOTH, cmd); if (ret == 0) { return true; } /* -ENOSYS means that commands for the RX and TX streams need * to be triggered separately. */ if (ret != -ENOSYS) { printk("Failed to trigger command %d: %d\n", cmd, ret); return false; } } ret = i2s_trigger(i2s_dev_rx, I2S_DIR_RX, cmd); if (ret < 0) { printk("Failed to trigger command %d on RX: %d\n", cmd, ret); return false; } ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, cmd); if (ret < 0) { printk("Failed to trigger command %d on TX: %d\n", cmd, ret); return false; } return true; } #define SAMPLE_BUFF (BLOCK_SIZE) int16_t sample[SAMPLE_BUFF]; int16_t sample2[SAMPLE_BUFF]; ssize_t bytes_read; int byte_count = 0; static void fill_buf(int16_t *tx_block) { // else // { // memset(sample, 0, SAMPLE_BUFF * sizeof(int16_t)); // } // Copy SAMPLE_BUFF (or BLOCK_SIZE) worth of data from sample to tx_block memcpy(tx_block, sample, BLOCK_SIZE * sizeof(int16_t)); // for (int i = 0; i < BLOCK_SIZE; i++) // { // if (byte_count > SAMPLE_BUFF) // { // byte_count = 0; // printk("Buffer was empty\n"); // // if (bytes_read = fs_read(&filep, &sample, sizeof(sample))) // // { // // } // } // tx_block[i] = sample[byte_count++]; // // if (i % 5 == 0) // // { // // tx_block[i] = 34000; // // } // // else // // { // // tx_block[i] = -34000; // // } // } } int main(void) { int ret; const struct device *const i2s_dev_rx = DEVICE_DT_GET(I2S_RX_NODE); const struct device *const i2s_dev_tx = DEVICE_DT_GET(I2S_TX_NODE); struct i2s_config config; printk("I2S echo sample\n"); // #if DT_ON_BUS(DT_NODELABEL(wm8731), i2c) // if (!init_wm8731_i2c()) { // return 0; // } // #endif if (!init_buttons()) { return 0; } if (!device_is_ready(i2s_dev_rx)) { printk("%s is not ready\n", i2s_dev_rx->name); return 0; } if (i2s_dev_rx != i2s_dev_tx && !device_is_ready(i2s_dev_tx)) { printk("%s is not ready\n", i2s_dev_tx->name); return 0; } config.word_size = SAMPLE_BIT_WIDTH; config.channels = NUMBER_OF_CHANNELS; config.format = I2S_FMT_DATA_FORMAT_LEFT_JUSTIFIED; config.options = I2S_OPT_BIT_CLK_MASTER | I2S_OPT_FRAME_CLK_MASTER; config.frame_clk_freq = SAMPLE_FREQUENCY; config.mem_slab = &mem_slab; config.block_size = BLOCK_SIZE; config.timeout = SYS_FOREVER_MS; // if (!configure_streams(i2s_dev_rx, i2s_dev_tx, &config)) // { // return 0; // } sd_card_mount(); lsdir(disk_mount_pt); fs_file_t_init(&filep); char *file_to_update = "MONO.WAV"; char fname1[255]; snprintf(fname1, sizeof(fname1), "%s/%s", mp.mnt_point, file_to_update); int res = fs_open(&filep, fname1, FS_O_READ); if (res) { printk("Error opening file %s [%d]\n", fname1, res); return res; } else { printk("File opened : %s\n", fname1); } // Skip the WAV header res = fs_seek(&filep, 44 + byte_count, FS_SEEK_SET); if (res < 0) { printk("Failed to seek past header: %d\n", res); fs_close(&filep); return; } // fs_close(&filep); // void *mem_block; // void *tx_block[INITIAL_BLOCKS]; // uint32_t tx_idx; // int ret; // while (1) // { // /* Prepare all TX blocks */ // for (tx_idx = 0; tx_idx < INITIAL_BLOCKS; tx_idx++) // { // ret = k_mem_slab_alloc(&mem_slab, &tx_block[tx_idx], // K_FOREVER); // if (ret < 0) // { // printf("Failed to allocate TX block\n"); // return ret; // } // fill_buf((uint16_t *)tx_block[tx_idx]); // } // tx_idx = 0; // /* Send first block */ // while (i2s_write(i2s_dev_tx, tx_block[tx_idx], BLOCK_SIZE)) // { // // if (ret < 0) // // { // printf("Could not write TX buffer 1 %d\n", tx_idx); // // return ret; // // } // } // tx_idx++; // /* Trigger the I2S transmission */ // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_START); // if (ret < 0) // { // printf("Could not trigger I2S tx\n"); // return ret; // } // for (; tx_idx < INITIAL_BLOCKS;) // { // ret = i2s_write(i2s_dev_tx, tx_block[tx_idx++], BLOCK_SIZE); // if (ret < 0) // { // printf("Could not write TX buffer 2 %d\n", tx_idx); // return ret; // } // } // /* Drain TX queue */ // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN); // if (ret < 0) // { // printf("Could not trigger I2S tx\n"); // return ret; // } // printf("All I2S blocks written\n"); // // k_msleep(180); // } if (bytes_read = fs_read(&filep, &sample, sizeof(sample))) { byte_count = byte_count + sizeof(sample); } ret = i2s_configure(i2s_dev_tx, I2S_DIR_TX, &config); if (ret < 0) { printk("Failed to configure TX stream: %d\n", ret); return false; } if (!prepare_transfer(i2s_dev_rx, i2s_dev_tx)) { return 0; } ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_START); if (ret < 0) { printf("Could not trigger I2S tx START\n"); return ret; } // if (!trigger_command(i2s_dev_rx, i2s_dev_tx, // I2S_TRIGGER_START)) // { // return 0; // } // if (!trigger_command(i2s_dev_rx, i2s_dev_tx, // I2S_TRIGGER_DRAIN)) // { // return 0; // } printk("Streams started : %u\n", (uint32_t *)BLOCK_SIZE); // printk("Init a while\n"); while (1) { /* Prepare all TX blocks */ // if (bytes_read = fs_read(&filep, &sample, sizeof(sample))) // { // } // else // { // memset(sample, 0, SAMPLE_BUFF * sizeof(int16_t)); // } void *tx_block = NULL; // explicitly initialize to NULL (good practice) uint32_t tx_idx; int ret; ret = k_mem_slab_alloc(&mem_slab, &tx_block, K_FOREVER); if (ret < 0) { printf("Failed to allocate TX block\n"); return ret; } memset(tx_block, 0, BLOCK_SIZE); // if (bytes_read = fs_read(&filep, &sample, sizeof(sample))) // { // } // else // { // memset(sample, 0, SAMPLE_BUFF * sizeof(int16_t)); // } memcpy(tx_block, sample, BLOCK_SIZE * sizeof(int16_t)); // fill_buf((uint16_t *)tx_block); /* Send first block */ printf("Going in\n"); if (i2s_write(i2s_dev_tx, tx_block, BLOCK_SIZE)) { // if (ret < 0) // { printf("Could not write TX buffer 1 %d\n", tx_idx); memset(tx_block, 0, BLOCK_SIZE); // return ret; // } } printf("Out form write\n"); // tx_idx++; /* Trigger the I2S transmission */ // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_START); // if (ret < 0) // { // printf("Could not trigger I2S tx START\n"); // return ret; // } // for (; tx_idx < INITIAL_BLOCKS;) // { // ret = i2s_write(i2s_dev_tx, tx_block[tx_idx++], BLOCK_SIZE); // if (ret < 0) // { // printf("Could not write TX buffer 2 %d\n", tx_idx); // return ret; // } // } /* Drain TX queue */ // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN); // if (ret < 0) // { // printf("Could not trigger I2S tx DRAIN\n"); // return ret; // } // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE); // if (ret < 0) // { // printf("Could not trigger I2S tx PREPARE\n"); // return ret; // } printf("All I2S blocks written\n"); // k_msleep(80); // res = fs_open(&filep, fname1, FS_O_READ); // if (res) // { // printk("Error opening file %s [%d]\n", fname1, res); // return res; // } // else // { // printk("File opened : %s\n", fname1); // } // Skip the WAV header // res = fs_seek(&filep, 44 + byte_count, FS_SEEK_SET); // if (res < 0) // { // printk("Failed to seek past header: %d\n", res); // fs_close(&filep); // return; // } printf("Goping to read\n"); if ((bytes_read = fs_read(&filep, &sample, sizeof(sample))) < 0) { printf("Error reading file: %d\n", bytes_read); // Handle the error or break out of the loop } printf("Out from read\n"); k_msleep(2000); // fs_close(&filep); } // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_STOP); // if (ret < 0) // { // printf("Could not trigger I2S tx STOP\n"); // // return ret; // } // } // if (bytes_read = fs_read(&filep, &sample, sizeof(sample))) // { // } // else // { // memset(sample, 0, SAMPLE_BUFF * sizeof(int16_t)); // } // void *mem_block; // int ret; // ret = k_mem_slab_alloc(&mem_slab, &mem_block, K_NO_WAIT); // // fill_buf((uint16_t *)mem_block); // // printk("Fil buffer!\n"); // memset(mem_block, 0, BLOCK_SIZE); // ret = i2s_write(i2s_dev_tx, mem_block, BLOCK_SIZE); // if (ret < 0) // { // printk("Failed to write block %d: %d\n", ret); // return false; // } // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_START); // if (ret < 0) // { // printk("Failed to trigger START on TX: %d\n", ret); // return false; // } // ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN); // if (ret < 0) // { // printk("Failed to trigger DRAIN on TX: %d\n", ret); // return false; // } printk("Streams stopped\n"); }
##### ERROR #####
*** Booting nRF Connect SDK v3.5.99-ncs1 ***<\r><\n> Attempting to boot slot 0.<\r><\r><\n> Attempting to boot from address 0x9200.<\r><\n> <\r>Verifying signature against key 0.<\r><\n> <\r>Hash: 0x70...81<\r><\r><\n> Firmware signature verified.<\r><\n> <\r>Firmware version 1<\r><\r><\n> Setting monotonic counter (version: 1, slot: 0)<\r><\r><\n> Booting (0x9200).<\r><\r>*** Booting nRF Connect SDK v3.5.99-ncs1 ***<\r><\n> I: Starting bootloader<\r><\n> I: Primary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Secondary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Boot source: none<\r><\n> I: Image index: 0, Swap type: none<\r><\n> I: Primary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Secondary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Boot source: none<\r><\n> I: Image index: 1, Swap type: none<\r><\n> I: Bootloader chainload address offset: 0x23000<\r><\n> I: Jumping to the first image slot<\r>?*** Booting nRF Connect SDK v3.5.99-ncs1 ***<\r><\n> I2S echo sample<\r><\n> Press "gpio@50000000" to toggle the echo effect<\r><\n> [00:00:00.034,484] <27>[0m<inf> sd: Maximum SD clock is under 25MHz, using clock of 8000000Hz<27>[0m<\r><\n> Block count 30535680Sector size 512<\r><\n> Memory Size(MB) 14910<\r><\n> Disk mounted.<\r><\n> <\r><\n> Listing dir /SD: ...<\r><\n> [DIR ] SYSTEM~1<\r><\n> [DIR ] DWIN_SET<\r><\n> [DIR ] DWIN_S~1<\r><\n> [DIR ] DWIN_S~2<\r><\n> [DIR ] DWIN_S~3<\r><\n> [FILE] APP_UP~1.BIN (size = 249376)<\r><\n> [FILE] TONE.WAV (size = 1048558)<\r><\n> [FILE] OTA_DA~1.TXT (size = 62)<\r><\n> [FILE] STEREO.WAV (size = 2035024)<\r><\n> [FILE] MONO.WAV (size = 1017824)<\r><\n> File opened : /SD:/MONO.WAV<\r><\n> [00:00:00.213,836] <27>[0m<inf> i2s_nrfx: I2S MCK frequency: 1391304, actual PCM rate: 43478<27>[0m<\r><\n> Streams started : 8820<\r><\n> Going in<\r><\n> Out form write<\r><\n> All I2S blocks written<\r><\n> Goping to read<\r><\n> Out from read<\r><\n> [00:00:00.529,693] <27>[1;31m<err> i2s_nrfx: Next buffers not supplied on time<27>[0m<\r><\n> Going in<\r><\n> [00:00:02.340,484] <27>[1;31m<err> i2s_nrfx: Cannot write in state: 4<27>[0m<\r><\n> Could not write TX buffer 1 0<\r><\n> Out form write<\r><\n> All I2S blocks written<\r><\n> Goping to read<\r><\n> Out from read<\r><\n> Going in<\r><\n> [00:00:04.464,233] <27>[1;31m<err> i2s_nrfx: Cannot write in state: 4<27>[0m<\r><\n> Could not write TX buffer 1 0<\r><\n> Out form write<\r><\n> All I2S blocks written<\r><\n> Goping to read<\r><\n> Out from read<\r><\n> [00:00:06.581,909] <27>[1;31m<err> os: ***** BUS FAULT *****<27>[0m<\r><\n> [00:00:06.587,677] <27>[1;31m<err> os: Precise data bus error<27>[0m<\r><\n> [00:00:06.608,795] <27>[1;31m<err> os: BFAR Address: 0xf7ee00f8<27>[0m<\r><\n> [00:00:06.630,126] <27>[1;31m<err> os: r0/a1: 0x2000053c r1/a2: 0x20008768 r2/a3: 0x00000000<27>[0m<\r><\n> [00:00:06.654,388] <27>[1;31m<err> os: r3/a4: 0xf7ee00f8 r12/ip: 0x00000000 r14/lr: 0x0002d99b<27>[0m<\r><\n> [00:00:06.678,588] <27>[1;31m<err> os: xpsr: 0x01000000<27>[0m<\r><\n> [00:00:06.699,218] <27>[1;31m<err> os: s[ 0]: 0x20000534 s[ 1]: 0x20008768 s[ 2]: 0xffffffff s[ 3]: 0x00000000<27>[0m<\r><\n> [00:00:06.725,341] <27>[1;31m<err> os: s[ 4]: 0x20000894 s[ 5]: 0x00034814 s[ 6]: 0x200014c0 s[ 7]: 0x20000534<27>[0m<\r><\n> [00:00:06.751,464] <27>[1;31m<err> os: s[ 8]: 0x00035753 s[ 9]: 0x00023a9d s[10]: 0x00035645 s[11]: 0x00000000<27>[0m<\r><\n> [00:00:06.777,557] <27>[1;31m<err> os: s[12]: 0xf7ee00f8 s[13]: 0x00030110 s[14]: 0x0000ac44 s[15]: 0x20000534<27>[0m<\r><\n> [00:00:06.803,649] <27>[1;31m<err> os: fpscr: 0x00002274<27>[0m<\r><\n> [00:00:06.824,249] <27>[1;31m<err> os: Faulting instruction address (r15/pc): 0x0002d9a0<27>[0m<\r><\n> [00:00:06.847,656] <27>[1;31m<err> os: >>> ZEPHYR FATAL ERROR 25: Unknown error on CPU 0<27>[0m<\r><\n> [00:00:06.871,032] <27>[1;31m<err> os: Current thread: 0x200006b0 (unknown)<27>[0m<\r><\n> [00:00:06.913,391] <27>[1;31m<err> fatal_error: Resetting system<27>[0m<\r>*** Booting nRF Connect SDK v3.5.99-ncs1 ***<\r><\n> Attempting to boot slot 0.<\r><\r><\n> Attempting to boot from address 0x9200.<\r><\n> <\r>Verifying signature against key 0.<\r><\n> <\r>Hash: 0x70...81<\r><\r><\n> Firmware signature verified.<\r><\n> <\r>Firmware version 1<\r><\r><\n> Booting (0x9200).<\r><\r>*** Booting nRF Connect SDK v3.5.99-ncs1 ***<\r><\n> I: Starting bootloader<\r><\n> I: Primary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Secondary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Boot source: none<\r><\n> I: Image index: 0, Swap type: none<\r><\n> I: Primary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Secondary image: magic=unset, swap_type=0x1, copy_done=0x3, image_ok=0x3<\r><\n> I: Boot source: none<\r><\n> I: Image index: 1, Swap type: none<\r><\n> I: Bootloader chainload address offset: 0x23000<\r><\n> I: Jumping to the first image slot<\r>?*** Booting nRF Connect SDK v3.5.99-ncs1 ***<\r><\n> I2S echo sample<\r><\n> Press "gpio@50000000" to toggle the echo effect<\r><\n> [00:00:00.034,484] <27>[0m<inf> sd: Maximum SD clock is under 25MHz, using clock of 8000000Hz<27>[0m<\r><\n> Block count 30535680Sector size 512<\r><\n> Memory Size(MB) 14910<\r><\n> Disk mounted.<\r><\n> <\r><\n> Listing dir /SD: ...<\r><\n> [DIR ] SYSTEM~1<\r><\n> [DIR ] DWIN_SET<\r><\n> [DIR ] DWIN_S~1<\r><\n> [DIR ] DWIN_S~2<\r><\n> [DIR ] DWIN_S~3<\r><\n> [FILE] APP_UP~1.BIN (size = 249376)<\r><\n> [FILE] TONE.WAV (size = 1048558)<\r><\n> [FILE] OTA_DA~1.TXT (size = 62)<\r><\n> [FILE] STEREO.WAV (size = 2035024)<\r><\n> [FILE] MONO.WAV (size = 1017824)<\r><\n> File opened : /SD:/MONO.WAV<\r><\n> [00:00:00.213,867] <27>[0m<inf> i2s_nrfx: I2S MCK frequency: 1391304, actual PCM rate: 43478<27>[0m<\r><\n> Streams started : 8820<\r><\n> Going in<\r><\n> Out form write<\r><\n> All I2S blocks written<\r><\n> Goping to read<\r><\n> Out from read<\r><\n> [00:00:00.529,724] <27>[1;31m<err> i2s_nrfx: Next buffers not supplied on time<27>[0m<\r><\n>