i2s_record_play

这章主要讲述i2s
1：环境及配件
esp32c3
esp32s3
idf5.4.1
INMP441
MAX98357A
都使用dma

2：eps32c3 测试
只有1个i2s 只能一边录 完 再播放 ，内存太小，这里用 flash 存audio里
只说能 录音 能播放 ，效果不好，后面再优化下
nvs, data, nvs, , 0x6000,
phy_init, data, phy, , 0x1000,
factory, app, factory, , 2M,
assets, data, spiffs, , 500K,
audio, data, spiffs, , 1M,

main/cmakefile
idf_component_register(SRCS “i2s_std_example_main.c”
#PRIV_REQUIRES nvs_flash esp_driver_i2s esp_driver_gpio i2s_examples_common
PRIV_REQUIRES nvs_flash driver spiffs
INCLUDE_DIRS “.”)
上代码

#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <sys/stat.h>
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "driver/i2s_std.h"
#include "esp_spiffs.h"// ========================== 基础配置 ==========================
#define SAMPLE_RATE     44100          // 44.1kHz采样率（人声常用）
#define MAX_RECORD_TIME 5.0f           // 最大录音时间：5秒（适配1M SPIFFS）
#define DATA_BIT_WIDTH  I2S_DATA_BIT_WIDTH_32BIT  // 32bit接收（适配INMP441的24bit输出）
#define BYTES_PER_SAMPLE 4             // 每采样字节数（32bit=4字节）
#define MAX_RECORD_SAMPLES (uint32_t)(MAX_RECORD_TIME * SAMPLE_RATE)  // 最大采样数：220500
#define MAX_RECORD_BYTES (MAX_RECORD_SAMPLES * BYTES_PER_SAMPLE)      // 最大录音字节数：882000字节// 硬件引脚配置
#define BUTTON_GPIO_NUM 2       // 按钮GPIO
#define I2S_NUM         I2S_NUM_0       // 使用I2S0
#define I2S_MCLK_GPIO   11      // INMP441必需的主时钟引脚
#define I2S_BCK_GPIO    3       // I2S位时钟（BCK）
#define I2S_WS_GPIO     10      // I2S字选择（LRCK）
#define I2S_DO_GPIO     6       // 扬声器数据输出
#define I2S_DI_GPIO     7       // INMP441数据输入// DMA配置（适配ESP32-C3内存）
#define DMA_DESC_NUM    6       // DMA描述符数量
#define DMA_FRAME_NUM   256     // 每个描述符帧数（256×4=1024字节/缓冲区）
#define DMA_BUFFER_BYTES (DMA_FRAME_NUM * BYTES_PER_SAMPLE)  // 单DMA缓冲区大小// SPIFFS配置（匹配分区表）
#define SPIFFS_PARTITION_LABEL "audio"  // 分区表中"audio"分区
#define RECORD_FILE_PATH "/spiffs/recording.raw"  // 录音文件路径
#define SPIFFS_MAX_OPEN_FILES 1        // 最大同时打开文件数static const char *TAG = "inmp441_spiffs_fixed";// ========================== 全局变量（补充任务句柄定义）==========================
static i2s_chan_handle_t tx_handle = NULL;  // 播放通道句柄
static i2s_chan_handle_t rx_handle = NULL;  // 录音通道句柄
static SemaphoreHandle_t i2s_mutex = NULL;   // I2S资源互斥锁
static SemaphoreHandle_t file_mutex = NULL;  // 文件操作互斥锁
static volatile bool button_pressed = false; // 按钮状态
static volatile bool is_recording = false;   // 录音状态
static volatile uint32_t recorded_samples = 0;  // 已录音采样数
// 补充任务句柄的全局定义（解决未定义错误）
static TaskHandle_t audio_record_task_handle = NULL;  // 录音任务句柄
static TaskHandle_t audio_play_task_handle = NULL;     // 播放任务句柄// ========================== 按钮中断处理 ==========================
static void IRAM_ATTR button_isr_handler(void *arg)
{int level = gpio_get_level(BUTTON_GPIO_NUM);button_pressed = (level == 0);if (level == 0) { // 按钮按下：启动录音is_recording = true;recorded_samples = 0;if (audio_record_task_handle != NULL) {BaseType_t xHigherPriorityTaskWoken = pdFALSE;vTaskNotifyGiveFromISR(audio_record_task_handle, &xHigherPriorityTaskWoken);portYIELD_FROM_ISR(xHigherPriorityTaskWoken);}} else { // 按钮释放：启动播放is_recording = false;if (audio_play_task_handle != NULL) {BaseType_t xHigherPriorityTaskWoken = pdFALSE;vTaskNotifyGiveFromISR(audio_play_task_handle, &xHigherPriorityTaskWoken);portYIELD_FROM_ISR(xHigherPriorityTaskWoken);}}
}// ========================== SPIFFS初始化 ==========================
static esp_err_t spiffs_audio_partition_init(void)
{ESP_LOGI(TAG, "Initializing SPIFFS (partition: %s)", SPIFFS_PARTITION_LABEL);esp_vfs_spiffs_conf_t spiffs_conf = {.base_path = "/spiffs",.partition_label = SPIFFS_PARTITION_LABEL,.max_files = SPIFFS_MAX_OPEN_FILES,.format_if_mount_failed = true};esp_err_t ret = esp_vfs_spiffs_register(&spiffs_conf);if (ret != ESP_OK) {if (ret == ESP_FAIL) ESP_LOGE(TAG, "SPIFFS mount failed");else if (ret == ESP_ERR_NOT_FOUND) ESP_LOGE(TAG, "SPIFFS partition not found");else ESP_LOGE(TAG, "SPIFFS init error: 0x%x", ret);return ret;}size_t total_size = 0, used_size = 0;ret = esp_spiffs_info(SPIFFS_PARTITION_LABEL, &total_size, &used_size);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to get SPIFFS info: 0x%x", ret);esp_vfs_spiffs_unregister(SPIFFS_PARTITION_LABEL);return ret;}ESP_LOGI(TAG, "SPIFFS mounted: Total=%d KB, Used=%d KB", total_size/1024, used_size/1024);return ESP_OK;
}// ========================== INMP441录音初始化 ==========================
static esp_err_t init_i2s_inmp441_dma(void)
{esp_err_t ret = ESP_OK;if (xSemaphoreTake(i2s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {ESP_LOGE(TAG, "Failed to take I2S mutex (recording)");return ESP_FAIL;}if (rx_handle != NULL) {i2s_channel_disable(rx_handle);i2s_del_channel(rx_handle);rx_handle = NULL;}i2s_chan_config_t chan_cfg = {.id = I2S_NUM,.role = I2S_ROLE_MASTER,.dma_desc_num = DMA_DESC_NUM,.dma_frame_num = DMA_FRAME_NUM,.auto_clear = true,.intr_priority = 0,};ret = i2s_new_channel(&chan_cfg, NULL, &rx_handle);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to create RX channel: 0x%x", ret);goto release_i2s_mutex;}i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(DATA_BIT_WIDTH, I2S_SLOT_MODE_MONO),.gpio_cfg = {.mclk = I2S_MCLK_GPIO,.bclk = I2S_BCK_GPIO,.ws = I2S_WS_GPIO,.dout = I2S_GPIO_UNUSED,.din = I2S_DI_GPIO,.invert_flags = {false, false, false}},};ret = i2s_channel_init_std_mode(rx_handle, &std_cfg);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to init RX mode: 0x%x", ret);goto delete_rx_channel;}ret = i2s_channel_enable(rx_handle);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to enable RX channel: 0x%x", ret);goto delete_rx_channel;}ESP_LOGI(TAG, "INMP441 DMA init success");return ESP_OK;delete_rx_channel:i2s_del_channel(rx_handle);rx_handle = NULL;
release_i2s_mutex:xSemaphoreGive(i2s_mutex);return ret;
}// ========================== 扬声器播放初始化 ==========================
static esp_err_t init_i2s_speaker_dma(void)
{esp_err_t ret = ESP_OK;if (xSemaphoreTake(i2s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {ESP_LOGE(TAG, "Failed to take I2S mutex (playback)");return ESP_FAIL;}if (tx_handle != NULL) {i2s_channel_disable(tx_handle);i2s_del_channel(tx_handle);tx_handle = NULL;}i2s_chan_config_t chan_cfg = {.id = I2S_NUM,.role = I2S_ROLE_MASTER,.dma_desc_num = DMA_DESC_NUM,.dma_frame_num = DMA_FRAME_NUM,.auto_clear = true,.intr_priority = 0,};ret = i2s_new_channel(&chan_cfg, &tx_handle, NULL);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to create TX channel: 0x%x", ret);goto release_i2s_mutex;}i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(DATA_BIT_WIDTH, I2S_SLOT_MODE_MONO),.gpio_cfg = {.mclk = I2S_GPIO_UNUSED,.bclk = I2S_BCK_GPIO,.ws = I2S_WS_GPIO,.dout = I2S_DO_GPIO,.din = I2S_GPIO_UNUSED,.invert_flags = {false, false, false}},};ret = i2s_channel_init_std_mode(tx_handle, &std_cfg);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to init TX mode: 0x%x", ret);goto delete_tx_channel;}ret = i2s_channel_enable(tx_handle);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to enable TX channel: 0x%x", ret);goto delete_tx_channel;}ESP_LOGI(TAG, "Speaker DMA init success");return ESP_OK;delete_tx_channel:i2s_del_channel(tx_handle);tx_handle = NULL;
release_i2s_mutex:xSemaphoreGive(i2s_mutex);return ret;
}// ========================== I2S资源释放 ==========================
static void deinit_i2s_dma(void)
{if (rx_handle != NULL) {i2s_channel_disable(rx_handle);i2s_del_channel(rx_handle);rx_handle = NULL;}if (tx_handle != NULL) {i2s_channel_disable(tx_handle);i2s_del_channel(tx_handle);tx_handle = NULL;}xSemaphoreGive(i2s_mutex);
}// ========================== 录音任务 ==========================
static void audio_record_task_dma(void *arg)
{ESP_LOGI(TAG, "Record task started (save to: %s)", RECORD_FILE_PATH);uint8_t dma_rx_buf[DMA_BUFFER_BYTES] = {0};while (1) {ulTaskNotifyTake(pdTRUE, portMAX_DELAY);ESP_LOGI(TAG, "Recording started (max %.1f sec)", MAX_RECORD_TIME);if (init_i2s_inmp441_dma() != ESP_OK) {ESP_LOGE(TAG, "INMP441 init failed, skip recording");continue;}FILE *rec_file = NULL;if (xSemaphoreTake(file_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {rec_file = fopen(RECORD_FILE_PATH, "wb");xSemaphoreGive(file_mutex);}if (rec_file == NULL) {ESP_LOGE(TAG, "Failed to open record file");deinit_i2s_dma();continue;}recorded_samples = 0;bool record_error = false;while (is_recording && recorded_samples < MAX_RECORD_SAMPLES && !record_error) {size_t bytes_read = 0;esp_err_t ret = i2s_channel_read(rx_handle,dma_rx_buf,DMA_BUFFER_BYTES,&bytes_read,pdMS_TO_TICKS(100));if (ret != ESP_OK || bytes_read == 0) {ESP_LOGE(TAG, "DMA read failed (ret=0x%x, bytes_read=%d)", ret, bytes_read);record_error = true;break;}uint32_t new_samples = bytes_read / BYTES_PER_SAMPLE;if (recorded_samples + new_samples > MAX_RECORD_SAMPLES) {new_samples = MAX_RECORD_SAMPLES - recorded_samples;bytes_read = new_samples * BYTES_PER_SAMPLE;is_recording = false;ESP_LOGW(TAG, "Reached max record time");}bool write_ok = false;if (xSemaphoreTake(file_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {size_t bytes_written = fwrite(dma_rx_buf, 1, bytes_read, rec_file);write_ok = (bytes_written == bytes_read);xSemaphoreGive(file_mutex);}if (write_ok) {recorded_samples += new_samples;if (recorded_samples % (uint32_t)(SAMPLE_RATE * 0.5) == 0) {ESP_LOGI(TAG, "Recorded: %.1f sec (%" PRIu32 " samples)", recorded_samples/(float)SAMPLE_RATE, recorded_samples);}} else {ESP_LOGE(TAG, "File write failed");record_error = true;}}if (xSemaphoreTake(file_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {fclose(rec_file);xSemaphoreGive(file_mutex);}deinit_i2s_dma();if (record_error) {ESP_LOGE(TAG, "Recording aborted due to error");} else {ESP_LOGI(TAG, "Recording finished: %.1f sec", recorded_samples/(float)SAMPLE_RATE);}}vTaskDelete(NULL);
}// ========================== 播放任务 ==========================
static void audio_play_task_dma(void *arg)
{ESP_LOGI(TAG, "Play task started (read from: %s)", RECORD_FILE_PATH);uint8_t dma_tx_buf[DMA_BUFFER_BYTES] = {0};while (1) {ulTaskNotifyTake(pdTRUE, portMAX_DELAY);ESP_LOGI(TAG, "Playback started");while (is_recording) vTaskDelay(pdMS_TO_TICKS(10));struct stat file_stat;bool file_exists = false;if (xSemaphoreTake(file_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {file_exists = (stat(RECORD_FILE_PATH, &file_stat) == 0);xSemaphoreGive(file_mutex);}if (!file_exists) {ESP_LOGW(TAG, "Record file not found");continue;} else if (file_stat.st_size == 0) {ESP_LOGW(TAG, "Record file is empty");recorded_samples = 0;continue;} else if (recorded_samples == 0) {recorded_samples = file_stat.st_size / BYTES_PER_SAMPLE;ESP_LOGW(TAG, "Sample count reset from file size: %" PRIu32, recorded_samples);}if (init_i2s_speaker_dma() != ESP_OK) {ESP_LOGE(TAG, "Speaker init failed, skip playback");continue;}FILE *play_file = NULL;if (xSemaphoreTake(file_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {play_file = fopen(RECORD_FILE_PATH, "rb");xSemaphoreGive(file_mutex);}if (play_file == NULL) {ESP_LOGE(TAG, "Failed to open play file");deinit_i2s_dma();continue;}size_t total_bytes_played = 0;const size_t total_play_bytes = recorded_samples * BYTES_PER_SAMPLE;bool play_error = false;while (total_bytes_played < total_play_bytes && !play_error) {size_t bytes_to_read = DMA_BUFFER_BYTES;if (total_bytes_played + bytes_to_read > total_play_bytes) {bytes_to_read = total_play_bytes - total_bytes_played;}size_t bytes_read = 0;if (xSemaphoreTake(file_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {bytes_read = fread(dma_tx_buf, 1, bytes_to_read, play_file);xSemaphoreGive(file_mutex);}if (bytes_read == 0) {ESP_LOGE(TAG, "File read failed");play_error = true;break;}size_t bytes_written = 0;esp_err_t ret = i2s_channel_write(tx_handle,dma_tx_buf,bytes_read,&bytes_written,pdMS_TO_TICKS(100));if (ret != ESP_OK || bytes_written != bytes_read) {ESP_LOGE(TAG, "DMA write failed (ret=0x%x, written=%d)", ret, bytes_written);play_error = true;break;}total_bytes_played += bytes_written;uint32_t played_samples = total_bytes_played / BYTES_PER_SAMPLE;if (played_samples % (uint32_t)(SAMPLE_RATE * 0.5) == 0) {ESP_LOGI(TAG, "Played: %.1f sec / %.1f sec", played_samples/(float)SAMPLE_RATE,recorded_samples/(float)SAMPLE_RATE);}}if (xSemaphoreTake(file_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {fclose(play_file);xSemaphoreGive(file_mutex);}deinit_i2s_dma();if (play_error) {ESP_LOGE(TAG, "Playback aborted due to error");} else {ESP_LOGI(TAG, "Playback finished: %.1f sec", recorded_samples/(float)SAMPLE_RATE);}}vTaskDelete(NULL);
}// ========================== 主函数 ==========================
void app_main(void)
{ESP_LOGI(TAG, "INMP441 SPIFFS DMA Loopback starting...");// 创建互斥锁i2s_mutex = xSemaphoreCreateMutex();file_mutex = xSemaphoreCreateMutex();if (i2s_mutex == NULL || file_mutex == NULL) {ESP_LOGE(TAG, "Failed to create semaphores");return;}// 初始化SPIFFSesp_err_t ret = spiffs_audio_partition_init();if (ret != ESP_OK) {ESP_LOGE(TAG, "SPIFFS init failed, app exit");vSemaphoreDelete(i2s_mutex);vSemaphoreDelete(file_mutex);return;}// 初始化按钮GPIOgpio_config_t io_conf = {.pin_bit_mask = (1ULL << BUTTON_GPIO_NUM),.mode = GPIO_MODE_INPUT,.pull_up_en = GPIO_PULLUP_ENABLE,.pull_down_en = GPIO_PULLDOWN_DISABLE,.intr_type = GPIO_INTR_ANYEDGE};ESP_ERROR_CHECK(gpio_config(&io_conf));ESP_ERROR_CHECK(gpio_install_isr_service(0));ESP_ERROR_CHECK(gpio_isr_handler_add(BUTTON_GPIO_NUM, button_isr_handler, NULL));// 创建录音/播放任务（使用全局句柄）xTaskCreate(audio_record_task_dma, "audio_record_task", 10240, NULL, 5, &audio_record_task_handle);xTaskCreate(audio_play_task_dma, "audio_play_task", 10240, NULL, 5, &audio_play_task_handle);ESP_LOGI(TAG, "App ready: Press button to record, release to play");
}

直接用内存的

#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "driver/i2s_std.h"// 定义常量
#define SAMPLE_RATE 16000
#define MAX_RECORD_TIME (3.0f)  // 最大录音时间（秒）
#define MAX_RECORD_SAMPLES (uint32_t)(MAX_RECORD_TIME * SAMPLE_RATE)  //16000*3 =48000
#define AUDIO_BUFFER_SIZE (MAX_RECORD_SAMPLES * sizeof(int16_t))  //48000*2 =96000// 根据您的硬件配置修改这些定义
#define BUTTON_GPIO_NUM 2       // 按钮连接到GPIO9
#define I2S_NUM I2S_NUM_0       // 使用I2S0
#define I2S_BCK_GPIO 3          // I2S位时钟GPIO
#define I2S_WS_GPIO 10          // I2S字选择GPIO
#define I2S_DO_GPIO 6           // I2S数据输出GPIO（播放到MAX98357）
#define I2S_DI_GPIO 7           // I2S数据输入GPIO（从INMP441录音）
//GAIN：增益控制（悬空=3dB，接地=9dB，接VDD=15dB）
static const char *TAG = "audio_loop";// 全局变量
static TaskHandle_t audio_play_task_handle = NULL;
static TaskHandle_t audio_record_task_handle = NULL;
static volatile bool is_recording = false;
static volatile uint32_t recorded_samples = 0;
static uint8_t *audio_buffer = NULL;
static i2s_chan_handle_t tx_handle = NULL;  // I2S TX通道句柄
static i2s_chan_handle_t rx_handle = NULL;  // I2S RX通道句柄
static SemaphoreHandle_t i2s_mutex = NULL;  // I2S资源互斥锁// 简单的按钮状态变量
static volatile bool button_pressed = false;// 按钮中断处理函数 - 简化版本，避免使用任何可能引起栈问题的函数
static void IRAM_ATTR button_isr_handler(void *arg)
{int level = gpio_get_level(BUTTON_GPIO_NUM);button_pressed = (level == 0);if (level == 0) { // 按下is_recording = true;recorded_samples = 0;// 使用轻量级通知方式if (audio_record_task_handle != NULL) {BaseType_t xHigherPriorityTaskWoken = pdFALSE;vTaskNotifyGiveFromISR(audio_record_task_handle, &xHigherPriorityTaskWoken);portYIELD_FROM_ISR(xHigherPriorityTaskWoken);}} else { // 释放is_recording = false;// 使用轻量级通知方式if (audio_play_task_handle != NULL) {BaseType_t xHigherPriorityTaskWoken = pdFALSE;vTaskNotifyGiveFromISR(audio_play_task_handle, &xHigherPriorityTaskWoken);portYIELD_FROM_ISR(xHigherPriorityTaskWoken);}}
}// 初始化I2S用于录音（INMP441）
static esp_err_t init_i2s_microphone(void)
{esp_err_t ret = ESP_OK;// 获取I2S资源锁if (xSemaphoreTake(i2s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {ESP_LOGE(TAG, "Failed to acquire I2S mutex for recording");return ESP_FAIL;}// 如果已有通道，先删除if (rx_handle != NULL) {i2s_channel_disable(rx_handle);i2s_del_channel(rx_handle);rx_handle = NULL;}// 配置I2S通道i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM, I2S_ROLE_MASTER);ret = i2s_new_channel(&chan_cfg, NULL, &rx_handle);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to create I2S RX channel: %d", ret);xSemaphoreGive(i2s_mutex);return ret;}// 配置I2S标准模式i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),.slot_cfg = I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO),.gpio_cfg = {.mclk = I2S_GPIO_UNUSED,  // INMP441不需要MCLK.bclk = I2S_BCK_GPIO,.ws = I2S_WS_GPIO,.dout = I2S_GPIO_UNUSED,.din = I2S_DI_GPIO,.invert_flags = {.mclk_inv = false,.bclk_inv = false,.ws_inv = false,},},};// 初始化RX通道ret = i2s_channel_init_std_mode(rx_handle, &std_cfg);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to init I2S RX channel: %d", ret);i2s_del_channel(rx_handle);rx_handle = NULL;xSemaphoreGive(i2s_mutex);return ret;}ret = i2s_channel_enable(rx_handle);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to enable I2S RX channel: %d", ret);i2s_del_channel(rx_handle);rx_handle = NULL;xSemaphoreGive(i2s_mutex);return ret;}return ESP_OK;
}// 初始化I2S用于播放（MAX98357）
static esp_err_t init_i2s_speaker(void)
{esp_err_t ret = ESP_OK;// 获取I2S资源锁if (xSemaphoreTake(i2s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {ESP_LOGE(TAG, "Failed to acquire I2S mutex for playback");return ESP_FAIL;}// 如果已有通道，先删除if (tx_handle != NULL) {i2s_channel_disable(tx_handle);i2s_del_channel(tx_handle);tx_handle = NULL;}// 配置I2S通道i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM, I2S_ROLE_MASTER);ret = i2s_new_channel(&chan_cfg, &tx_handle, NULL);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to create I2S TX channel: %d", ret);xSemaphoreGive(i2s_mutex);return ret;}// 配置I2S标准模式i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),.slot_cfg = I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO),.gpio_cfg = {.mclk = I2S_GPIO_UNUSED,  // MAX98357不需要MCLK.bclk = I2S_BCK_GPIO,.ws = I2S_WS_GPIO,.dout = I2S_DO_GPIO,.din = I2S_GPIO_UNUSED,.invert_flags = {.mclk_inv = false,.bclk_inv = false,.ws_inv = false,},},};// 初始化TX通道ret = i2s_channel_init_std_mode(tx_handle, &std_cfg);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to init I2S TX channel: %d", ret);i2s_del_channel(tx_handle);tx_handle = NULL;xSemaphoreGive(i2s_mutex);return ret;}ret = i2s_channel_enable(tx_handle);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to enable I2S TX channel: %d", ret);i2s_del_channel(tx_handle);tx_handle = NULL;xSemaphoreGive(i2s_mutex);return ret;}return ESP_OK;
}// 完全释放I2S资源
static void deinit_i2s(void)
{// 禁用并删除RX通道if (rx_handle != NULL) {i2s_channel_disable(rx_handle);i2s_del_channel(rx_handle);rx_handle = NULL;}// 禁用并删除TX通道if (tx_handle != NULL) {i2s_channel_disable(tx_handle);i2s_del_channel(tx_handle);tx_handle = NULL;}// 释放I2S资源锁xSemaphoreGive(i2s_mutex);
}// 音频播放任务
static void audio_play_task(void *arg)
{ESP_LOGI(TAG, "Audio play task started");while (1) {// 等待通知开始播放ulTaskNotifyTake(pdTRUE, portMAX_DELAY);// 确保录音已经停止while (is_recording) {vTaskDelay(pdMS_TO_TICKS(10));}if (recorded_samples > 0) {ESP_LOGI(TAG, "Start playback, recorded samples: %" PRIu32, recorded_samples);// 初始化I2S用于播放if (init_i2s_speaker() != ESP_OK) {ESP_LOGE(TAG, "Failed to initialize I2S for playback");continue;}// 播放录音size_t bytes_written = 0;size_t total_bytes = recorded_samples * sizeof(int16_t);while (bytes_written < total_bytes) {size_t bytes_to_write = total_bytes - bytes_written;if (bytes_to_write > 4096) bytes_to_write = 4096; // 每次最多写入4KBsize_t bytes_written_this_time = 0;i2s_channel_write(tx_handle, audio_buffer + bytes_written, bytes_to_write, &bytes_written_this_time, portMAX_DELAY);bytes_written += bytes_written_this_time;// 添加小延迟，避免任务占用过多CPUvTaskDelay(pdMS_TO_TICKS(1));}// 禁用并删除通道deinit_i2s();ESP_LOGI(TAG, "Playback finished");} else {ESP_LOGW(TAG, "No audio data to play");}}vTaskDelete(NULL);
}// 音频录音任务
static void audio_record_task(void *arg)
{ESP_LOGI(TAG, "Audio record task started");while(1) {// 等待通知开始录音ulTaskNotifyTake(pdTRUE, portMAX_DELAY);ESP_LOGI(TAG, "Start recording");// 初始化I2S用于录音if (init_i2s_microphone() != ESP_OK) {ESP_LOGE(TAG, "Failed to initialize I2S for recording");continue;}recorded_samples = 0;// 录音直到按钮释放或达到最大时间while (is_recording && recorded_samples < MAX_RECORD_SAMPLES) {// 每次读取100ms的音频数据uint32_t samples_to_read = SAMPLE_RATE / 10;if (recorded_samples + samples_to_read > MAX_RECORD_SAMPLES) {samples_to_read = MAX_RECORD_SAMPLES - recorded_samples;}size_t bytes_read = 0;i2s_channel_read(rx_handle, audio_buffer + (recorded_samples * sizeof(int16_t)), samples_to_read * sizeof(int16_t),&bytes_read,portMAX_DELAY);if (bytes_read > 0) {recorded_samples += bytes_read / sizeof(int16_t);// 减少日志输出频率，避免占用过多资源if (recorded_samples % (SAMPLE_RATE / 2) == 0) {ESP_LOGI(TAG, "Recorded %" PRIu32 " samples", recorded_samples);}} else {ESP_LOGE(TAG, "Failed to read audio data");break;}vTaskDelay(pdMS_TO_TICKS(10)); // 稍微延迟以避免任务占用过多CPU}// 禁用并删除通道deinit_i2s();ESP_LOGI(TAG, "Recording finished, total samples: %" PRIu32, recorded_samples);}vTaskDelete(NULL);
}void app_main(void)
{ESP_LOGI(TAG, "Audio loopback application starting");// 创建I2S资源互斥锁i2s_mutex = xSemaphoreCreateMutex();if (i2s_mutex == NULL) {ESP_LOGE(TAG, "Failed to create I2S mutex");return;}// 初始化按钮GPIOgpio_config_t io_conf = {.pin_bit_mask = (1ULL << BUTTON_GPIO_NUM),.mode = GPIO_MODE_INPUT,.pull_up_en = GPIO_PULLUP_ENABLE,.pull_down_en = GPIO_PULLDOWN_DISABLE,.intr_type = GPIO_INTR_ANYEDGE,};esp_err_t ret = gpio_config(&io_conf);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to configure button GPIO: %d", ret);vSemaphoreDelete(i2s_mutex);return;}// 安装GPIO中断服务ret = gpio_install_isr_service(0);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to install GPIO ISR service: %d", ret);vSemaphoreDelete(i2s_mutex);return;}ret = gpio_isr_handler_add(BUTTON_GPIO_NUM, button_isr_handler, NULL);if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to add GPIO ISR handler: %d", ret);vSemaphoreDelete(i2s_mutex);return;}// 分配音频缓冲区audio_buffer = heap_caps_malloc(AUDIO_BUFFER_SIZE, MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);if (audio_buffer == NULL) {// 如果SPIRAM不可用，尝试内部内存audio_buffer = malloc(AUDIO_BUFFER_SIZE);if (audio_buffer == NULL) {ESP_LOGE(TAG, "Failed to allocate audio buffer of size %" PRIu32, (uint32_t)AUDIO_BUFFER_SIZE);vSemaphoreDelete(i2s_mutex);return;}ESP_LOGI(TAG, "Audio buffer allocated in internal memory");} else {ESP_LOGI(TAG, "Audio buffer allocated in SPIRAM");}memset(audio_buffer, 0, AUDIO_BUFFER_SIZE);// 创建任务 - 增加栈大小xTaskCreate(audio_play_task, "audio_play_task", 8192, NULL, 5, &audio_play_task_handle);xTaskCreate(audio_record_task, "audio_record_task", 8192, NULL, 5, &audio_record_task_handle);ESP_LOGI(TAG, "Audio loopback application started");ESP_LOGI(TAG, "Press and hold the button to record, release to play");
}

3：eps32s3 n16r8
配置
Partition Table
Single factory app (large), no OTA
Offset of partition table
0x8000

参考 https://blog.csdn.net/qq_44392698/article/details/147032820
实时录音播放 别人的代码 修改下

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/i2s_std.h"
#include "driver/gpio.h"#define BUTTON_GPIO_NUM 47      // 按钮连接到GPIO9
//INMP引脚，根据自己连线修改
#define INMP_SD     GPIO_NUM_6
#define INMP_SCK    GPIO_NUM_5
#define INMP_WS     GPIO_NUM_4//MAX98357A引脚，根据自己连线修改
#define MAX_DIN     GPIO_NUM_7
#define MAX_BCLK    GPIO_NUM_15
#define MAX_LRC     GPIO_NUM_16//配置rx对INMP441的采样率为44.1kHz，这是常用的人声采样率
#define SAMPLE_RATE 44100//buf size计算方法：根据esp32官方文档，buf size = dma frame num * 声道数 * 数据位宽 / 8
#define BUF_SIZE    (1023 * 1 * 32 / 8)//音频buffer
uint8_t buf[BUF_SIZE];i2s_chan_handle_t rx_handle;
i2s_chan_handle_t tx_handle;//初始化i2s rx，用于从INMP441接收数据
static void i2s_rx_init(void)
{i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);//dma frame num使用最大值，增大dma一次搬运的数据量，能够提高效率，减小杂音，使用1023可以做到没有一丝杂音chan_cfg.dma_frame_num = 511;i2s_new_channel(&chan_cfg, NULL, &rx_handle);i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),//虽然inmp441采集数据为24bit，但是仍可使用32bit来接收，中间存储过程不需考虑，只要让声音怎么进来就怎么出去即可.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_32BIT, I2S_SLOT_MODE_STEREO),.gpio_cfg = {.mclk = I2S_GPIO_UNUSED,.dout = I2S_GPIO_UNUSED,.bclk = INMP_SCK,.ws = INMP_WS,.din = INMP_SD,.invert_flags = {.mclk_inv = false,.bclk_inv = false,.ws_inv = false,},},};i2s_channel_init_std_mode(rx_handle, &std_cfg);i2s_channel_enable(rx_handle);
}//初始化tx，用于向MAX98357A写数据
static void i2s_tx_init(void)
{i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_1, I2S_ROLE_MASTER);chan_cfg.dma_frame_num = 511;i2s_new_channel(&chan_cfg, &tx_handle, NULL);i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_32BIT,I2S_SLOT_MODE_STEREO),.gpio_cfg = {.mclk = I2S_GPIO_UNUSED,.din = I2S_GPIO_UNUSED,.bclk = MAX_BCLK,.ws = MAX_LRC,.dout = MAX_DIN,.invert_flags = {.mclk_inv = false,.bclk_inv = false,.ws_inv = false,},},};i2s_channel_init_std_mode(tx_handle, &std_cfg);i2s_channel_enable(tx_handle);
}static void i2s_read_task(void *args)
{size_t bytes = 0;//一次性读取buf_size数量的音频，即dma最大搬运一次的数据量，读成功后，写入tx，即可通过MAX98357A播放while (1) {if (i2s_channel_read(rx_handle, buf, BUF_SIZE, &bytes, 1000) == ESP_OK){i2s_channel_write(tx_handle, buf, BUF_SIZE, &bytes, 1000);}vTaskDelay(pdMS_TO_TICKS(5));}vTaskDelete(NULL);
}void app_main(void){i2s_tx_init();i2s_rx_init();xTaskCreate(i2s_read_task, "i2s_read_task", 4096 * 2, NULL, tskIDLE_PRIORITY, NULL);
}

按键47 录音 播放 接线直接按小智AI

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/i2s_std.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_intr_alloc.h"
#include "esp_heap_caps.h"static const char *TAG = "inmp441_MAX98357A";#define RECORD_BUTTON_GPIO_NUM 47 // Record/play control button connected to GPIO47// INMP pin configuration
#define INMP_SD     GPIO_NUM_6
#define INMP_SCK    GPIO_NUM_5
#define INMP_WS     GPIO_NUM_4// MAX98357A pin configuration
#define MAX_DIN     GPIO_NUM_7
#define MAX_BCLK    GPIO_NUM_15
#define MAX_LRC     GPIO_NUM_16// Sample rate configuration
#define SAMPLE_RATE 22050 // 降低采样率以减少内存使用// Calculate buffer size for 2 seconds of audio
#define RECORD_DURATION 2 // Record for 2 seconds
#define BUFFER_SIZE (SAMPLE_RATE * RECORD_DURATION * 2 * (16 / 8)) // 使用16位而不是32位// Task handles
TaskHandle_t record_task_handle = NULL;
TaskHandle_t play_task_handle = NULL;// Audio buffer (allocated on heap)
uint8_t *audio_buffer = NULL;
size_t recorded_bytes = 0; // Track actual recorded bytes// Button event queue
QueueHandle_t button_event_queue = NULL;// Button events
typedef enum {BUTTON_PRESSED,BUTTON_RELEASED
} button_event_t;i2s_chan_handle_t rx_handle;
i2s_chan_handle_t tx_handle;// GPIO interrupt handler
static void IRAM_ATTR gpio_isr_handler(void* arg)
{uint32_t gpio_num = (uint32_t) arg;button_event_t event = gpio_get_level(gpio_num) == 0 ? BUTTON_PRESSED : BUTTON_RELEASED;// Send event to queueBaseType_t xHigherPriorityTaskWoken = pdFALSE;xQueueSendFromISR(button_event_queue, &event, &xHigherPriorityTaskWoken);if (xHigherPriorityTaskWoken) {portYIELD_FROM_ISR();}
}// Initialize I2S receiver (INMP441)
static void i2s_rx_init(void)
{i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);chan_cfg.dma_frame_num = 256; // 减少DMA帧数ESP_ERROR_CHECK(i2s_new_channel(&chan_cfg, NULL, &rx_handle));i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO),.gpio_cfg = {.mclk = I2S_GPIO_UNUSED,.dout = I2S_GPIO_UNUSED,.bclk = INMP_SCK,.ws = INMP_WS,.din = INMP_SD,.invert_flags = {.mclk_inv = false,.bclk_inv = false,.ws_inv = false,},},};ESP_ERROR_CHECK(i2s_channel_init_std_mode(rx_handle, &std_cfg));ESP_ERROR_CHECK(i2s_channel_enable(rx_handle));
}// Initialize I2S transmitter (MAX98357A)
static void i2s_tx_init(void)
{i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_1, I2S_ROLE_MASTER);chan_cfg.dma_frame_num = 256; // 减少DMA帧数ESP_ERROR_CHECK(i2s_new_channel(&chan_cfg, &tx_handle, NULL));i2s_std_config_t std_cfg = {.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO),.gpio_cfg = {.mclk = I2S_GPIO_UNUSED,.din = I2S_GPIO_UNUSED,.bclk = MAX_BCLK,.ws = MAX_LRC,.dout = MAX_DIN,.invert_flags = {.mclk_inv = false,.bclk_inv = false,.ws_inv = false,},},};ESP_ERROR_CHECK(i2s_channel_init_std_mode(tx_handle, &std_cfg));ESP_ERROR_CHECK(i2s_channel_enable(tx_handle));
}// Record task
static void record_task(void *arg)
{ESP_LOGI(TAG, "Record task started");while (1) {// Wait for notification to start recordingulTaskNotifyTake(pdTRUE, portMAX_DELAY);ESP_LOGI(TAG, "Starting recording");size_t bytes_read = 0;recorded_bytes = 0;// Record audio for 2 secondswhile (recorded_bytes < BUFFER_SIZE) {if (i2s_channel_read(rx_handle, audio_buffer + recorded_bytes, BUFFER_SIZE - recorded_bytes, &bytes_read, 1000) == ESP_OK) {recorded_bytes += bytes_read;}vTaskDelay(pdMS_TO_TICKS(1));}ESP_LOGI(TAG, "Recording completed, recorded %u bytes", recorded_bytes);// Notify play task that recording is completexTaskNotifyGive(play_task_handle);}
}// Play task
static void play_task(void *arg)
{ESP_LOGI(TAG, "Play task started");while (1) {// Wait for notification to start playingulTaskNotifyTake(pdTRUE, portMAX_DELAY);if (recorded_bytes == 0) {ESP_LOGI(TAG, "No audio recorded, cannot play");continue;}ESP_LOGI(TAG, "Starting playback");size_t bytes_written = 0;size_t offset = 0;while (offset < recorded_bytes) {if (i2s_channel_write(tx_handle, audio_buffer + offset, recorded_bytes - offset, &bytes_written, 1000) == ESP_OK) {offset += bytes_written;}vTaskDelay(pdMS_TO_TICKS(1));}ESP_LOGI(TAG, "Playback completed");}
}// Button task to handle button events
static void button_task(void *arg)
{button_event_t event;bool recording_active = false;ESP_LOGI(TAG, "Button task started");while (1) {if (xQueueReceive(button_event_queue, &event, portMAX_DELAY)) {// Simple debouncing - ignore events that come too quicklystatic TickType_t last_event_time = 0;TickType_t current_time = xTaskGetTickCount();if (current_time - last_event_time > pdMS_TO_TICKS(50)) {last_event_time = current_time;if (event == BUTTON_PRESSED) {ESP_LOGI(TAG, "Button pressed, starting recording");recording_active = true;// Notify record task to startxTaskNotifyGive(record_task_handle);} else if (event == BUTTON_RELEASED && recording_active) {ESP_LOGI(TAG, "Button released");recording_active = false;// Notify play task to start (it will wait for record task to finish)}}}}
}void app_main(void)
{ESP_LOGI(TAG, "Free heap: %lu bytes", esp_get_free_heap_size());ESP_LOGI(TAG, "Largest free block: %u bytes", heap_caps_get_largest_free_block(MALLOC_CAP_8BIT));// Allocate audio buffer on heap using special function for large allocationsaudio_buffer = (uint8_t*)heap_caps_malloc(BUFFER_SIZE, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);if (audio_buffer == NULL) {// If SPIRAM is not available, try normal allocationaudio_buffer = (uint8_t*)malloc(BUFFER_SIZE);if (audio_buffer == NULL) {ESP_LOGE(TAG, "Failed to allocate audio buffer of size %d bytes", BUFFER_SIZE);//        ESP_LOGI(TAG, "Available heap: %ld bytes", esp_get_free_heap_size());return;}ESP_LOGI(TAG, "Audio buffer allocated in internal RAM: %d bytes", BUFFER_SIZE);} else {ESP_LOGI(TAG, "Audio buffer allocated in SPIRAM: %d bytes", BUFFER_SIZE);}// Create button event queuebutton_event_queue = xQueueCreate(5, sizeof(button_event_t));// Initialize record/play control button GPIO with interruptgpio_config_t io_conf = {.pin_bit_mask = (1ULL << RECORD_BUTTON_GPIO_NUM),.mode = GPIO_MODE_INPUT,.pull_up_en = GPIO_PULLUP_ENABLE,.pull_down_en = GPIO_PULLDOWN_DISABLE,.intr_type = GPIO_INTR_ANYEDGE, // Interrupt on both rising and falling edges};gpio_config(&io_conf);// Install GPIO ISR servicegpio_install_isr_service(0);// Add ISR handler for GPIOgpio_isr_handler_add(RECORD_BUTTON_GPIO_NUM, gpio_isr_handler, (void*)RECORD_BUTTON_GPIO_NUM);// Initialize I2Si2s_tx_init();i2s_rx_init();ESP_LOGI(TAG, "System initialization completed");ESP_LOGI(TAG, "Press and hold GPIO47 button to record, release to play");// Create tasks with smaller stack sizesxTaskCreate(record_task, "record_task", 3072, NULL, 5, &record_task_handle);xTaskCreate(play_task, "play_task", 3072, NULL, 5, &play_task_handle);xTaskCreate(button_task, "button_task", 2048, NULL, 6, NULL);// Keep main task alivewhile (1) {vTaskDelay(pdMS_TO_TICKS(1000));}
}

4： 如果对你又帮助，麻烦点个赞，加个关注
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/web/97972.shtml
繁体地址，请注明出处：http://hk.pswp.cn/web/97972.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Spring Boot 3 + EasyExcel 文件导入导出实现

Spring Boot 3 + EasyExcel 文件导入导出实现

SpringBoot集成EasyExcel 3.x&#xff1a;高效实现Excel数据的优雅导入与导出 在现代企业应用中&#xff0c;Excel作为数据交换的重要工具&#xff0c;几乎无处不在。如何高效且优雅地实现Excel数据的导入与导出&#xff0c;是每个开发者都需要面对的问题。EasyExcel是阿里巴巴…
阅读更多...
Ruby编程实践：20个实用练习

Ruby编程实践：20个实用练习

1、编写一个程序，计算一年有多少小时。 以下是两种实现方式的代码： 方式一： puts 24*365方式二： puts 24*365 puts "(or #{24*366} on a leap year)"2、编写一个程序，计算十年中有多少分钟。 以下两种实现方式： 简单计算（未考虑闰年数量差异）： ru…
阅读更多...
逻辑回归（二）：从原理到实战 - 训练、评估与应用指南

逻辑回归（二）：从原理到实战 - 训练、评估与应用指南

引言&#xff1a; 上期我们讲了什么是逻辑回归&#xff0c;了解了它如何利用Sigmoid函数将线性回归的输出转化为概率&#xff0c;并通过最大似然估计来寻找最佳参数。今天&#xff0c;我们将继续这段旅程&#xff0c;学习如何训练这个 模型、如何评估它的表现&#xff0c;以及如…
阅读更多...
9.8C++作业

9.8C++作业

思维导图#include <iostream> #include <vector> #include <fstream> using namespace std;class Stu {friend ofstream &operator<<(ofstream &ofs,const Stu &stu); private:string name;string id;int age;double score; public:Stu(){…
阅读更多...
Linux内存管理章节十六:非均匀的内存访问：深入Linux NUMA架构内存管理

Linux内存管理章节十六:非均匀的内存访问：深入Linux NUMA架构内存管理

引言 在传统的SMP&#xff08;对称多处理&#xff09;系统中&#xff0c;所有CPU核心通过一条共享总线访问同一块内存&#xff0c;所有内存访问延迟是均匀的&#xff08;UMA&#xff09;。然而&#xff0c;随着CPU核心数量的增加&#xff0c;共享总线成为了巨大的性能和 scalab…
阅读更多...
【论文翻译】Seg-Zero: Reasoning-Chain Guided Segmentation via Cognitive Reinforcement

【论文翻译】Seg-Zero: Reasoning-Chain Guided Segmentation via Cognitive Reinforcement

0. 摘要Traditional methods for reasoning segmentation rely on supervised fine-tuning with categorical labels and simple descriptions, limiting its out-of-domain generalization and lacking explicit reasoning processes. To address these limitations, we propo…
阅读更多...
Playwright MCP浏览器自动化教程

Playwright MCP浏览器自动化教程

你是否曾厌倦在编程软件和浏览器之间反复切换&#xff0c;只为了检查AI生成的代码能否正常运行&#xff1f;现在&#xff0c;有了Playwright MCP&#xff08;Model Context Protocol&#xff09;&#xff0c;你可以直接让AI自己操作浏览器&#xff0c;查看自己写的代码运行效果…
阅读更多...
矩阵中遍历某个点周围的九个点

矩阵中遍历某个点周围的九个点

又是学习新知识的一天,以下为Java版本部分关键代码int[] neighbors {0, 1, -1};int rows board.length;int cols board[0].length;int[][] copyBoard new int[rows][cols];for (int row 0; row < rows; row) {for (int col 0; col < cols; col) {int liveNeighbors…
阅读更多...
单例模式：只有一个对象

单例模式：只有一个对象

目录 什么是单例模式 能解决什么问题 使用场景 如何实现 __new__ 方法&#xff1a;经典又直接 装饰器&#xff1a;不改类本身&#xff0c;也能单例 模块本身就是单例 注意事项 总结 你有没有过这样的困扰&#xff1a; “为什么我明明只创建了一次数据库连接&#xff0…
阅读更多...
AI大模型学习（6）Yolo V8神经网络的基础应用

AI大模型学习（6）Yolo V8神经网络的基础应用

Yolo V8神经网络的基础应用2024-2025年最火的目标检测神器&#xff0c;一篇文章让你彻底搞懂&#xff01;&#x1f929;大家好呀&#xff01;今天我们要聊一聊计算机视觉领域的「明星模型」——YOLO神经网络&#xff01;&#x1f3af; 如果你对「目标检测」这个词还比较陌生&am…
阅读更多...
C++:imagehlp库

C++:imagehlp库

imagehlp库1. 简介2. 主要函数与用途2.1PE 文件解析相关2.2 符号处理相关2.3 崩溃转储相关2.4 版本资源相关3. 使用示例3.1 解析内存地址对应的函数名和行号3.2 创建目录使用示例1. 简介 imagehlp 是 Windows 系统提供的一个图像处理与调试辅助 API 库&#xff08;Image Helpe…
阅读更多...
如何在Anaconda中配置你的CUDA Pytorch cuNN环境（2025最新教程）

如何在Anaconda中配置你的CUDA Pytorch cuNN环境（2025最新教程）

目录 一、简介 二、下载CUDA 三、下载Pytorch-GPU版本 四、下载CUDNN 五、总结 六、测试代码 一、简介 啥是Anaconda?啥是CUDA?啥是CUDNN&#xff1f;它们和Pytorch、GPU之间有啥关系? 怎么通俗解释它们三者的用途和关系&#xff1f; 1.GPU(图形处理单元&#xff09…
阅读更多...
算法面试（1）-----目标检测和图像分类、语义分割的区别

算法面试（1）-----目标检测和图像分类、语义分割的区别

操作系统&#xff1a;ubuntu22.04 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 目标检测&#xff08;Object Detection&#xff09;、图像分类&#xff08;Image Classification&#xff09;、语义分割&#xff08;Semantic Segmentation&#xff09; 是计算机视…
阅读更多...
电脑散热风扇有噪音怎么解决

电脑散热风扇有噪音怎么解决

一、初步检查与清理断电并拆机关闭电脑并拔掉电源&#xff0c;打开机箱侧板&#xff08;笔记本需先拆除后盖螺丝&#xff09;。操作前建议佩戴防静电手环&#xff0c;避免静电损坏硬件。清理风扇及散热片灰尘使用压缩空气罐从风扇进风口吹走灰尘&#xff0c;或用软毛刷轻轻刷去…
阅读更多...
SeaweedFS深度解析（九）：k8s环境使用helm部署Seaweedfs集群

SeaweedFS深度解析（九）：k8s环境使用helm部署Seaweedfs集群

上一篇&#xff1a;《SeaweedFS深度解析&#xff08;八&#xff09;&#xff1a;k8s环境使用Operator部署Seaweedfs集群》 链接: link #作者&#xff1a;闫乾苓 文章目录k8s环境使用helm部署Seaweedfs集群准备镜像seaweed-master-localpv-storageclass.yamlseaweed-volume-lo…
阅读更多...
MATLAB绘制一个新颖的混沌图像(新四翼混沌系统)

MATLAB绘制一个新颖的混沌图像(新四翼混沌系统)

新四翼混沌系统:dx/dt a(y - x) yz dy/dt cx - y - xz dz/dt -bz xyMATLAB代码:function plot_novel_chaotic_system() % 参数设置 a 10; b 8/3; c 28;% 初始条件 x0 [1, 1, 1];% 时间范围 tspan [0 100];% 求解微分方程 [t, x] ode45((t, x) chaotic_system(t, x, …
阅读更多...
金融数据---获取股票日线数据

金融数据---获取股票日线数据

获取股票日线的数据方式有很多&#xff0c;包括东方财富&#xff0c;同花顺&#xff0c;tushare&#xff0c;这里我们就利用东方财富的数据&#xff0c;是免费的开源获取&#xff0c;第一步先安装akshare&#xff0c;pip安装就可以py -m pip install akshareAkshare 股票数据获…
阅读更多...
Mac 真正多显示器支持：TESmart USB-C KVM（搭载 DisplayLink 技术）如何实现

Mac 真正多显示器支持：TESmart USB-C KVM（搭载 DisplayLink 技术）如何实现

多显示器已经不再是奢侈品&#xff0c;而是专业人士提升生产力的必需工具。无论是创意设计师、股票交易员还是软件开发人员&#xff0c;多屏幕都能让工作流程更高效、更有条理。 然而&#xff0c;Mac 用户长期以来面临一个主要障碍&#xff1a;macOS 原生不支持多流传输&#x…
阅读更多...
【实时Linux实战系列】静态链接与libc选择：musl vs glibc的时延权衡

【实时Linux实战系列】静态链接与libc选择：musl vs glibc的时延权衡

背景与重要性 在实时系统开发中&#xff0c;选择合适的C标准库&#xff08;libc&#xff09;和链接方式对系统的启动时间、线程性能和内存分配效率有着显著影响。glibc和musl是两种流行的C标准库实现&#xff0c;它们在设计目标和性能表现上存在差异。通过对比这两种libc在启动…
阅读更多...
Altium Designer（AD24）的三种文件组织形式，工程文件，自由文件与存盘文件

Altium Designer（AD24）的三种文件组织形式，工程文件，自由文件与存盘文件

🏡《专栏目录》 目录 1，概述 2，工程文件 3，自由文件 4，存盘文件 5，文件转换 5.1，工程文件于自由文件互转换 5.2，工程文件于存盘文件互转换 6，注意事项 1，概述 本文介绍Altium Designer 24软件（后文简称AD24或软件）的三种文件组织形式，工程文件，自由文件和存盘文…
阅读更多...
最新文章

Copyright @ 2022~2023