一、系统概述与核心功能

1. 系统定位

基于STM32与FastICA算法的语音增强系统以"多通道语音采集-盲源分离-噪声抑制-语音增强输出"为核心，通过两个及以上麦克风采集混合语音信号（目标语音+噪声/干扰语音），利用FastICA（Fast Independent Component Analysis，快速独立成分分析）算法实现盲源分离，从混合信号中提取干净的语音信号，显著提升语音清晰度和信噪比（SNR），适用于电话会议、助听设备、智能音箱、语音识别前端处理等场景。

2. 核心功能模块

模块	功能描述
多通道采集	2~4路麦克风阵列同步采样，16kHz/16bit，ADC同步采集，保证通道间相位一致性
信号预处理	去均值、预白化（PCA）、加窗分帧（Hamming窗，25ms帧长，10ms帧移）
FastICA分离	固定点迭代算法，估计分离矩阵W，从混合信号中分离出独立语音源
语音增强	谱减法/维纳滤波/MMSE估计，进一步去除残留噪声，提升语音自然度
回声消除	可选AEC模块，消除扬声器播放对自身麦克风的回声干扰
低功耗设计	待机电流<1mA，语音活动检测（VAD）触发唤醒，锂电池续航≥8小时

二、硬件设计方案

1. 核心硬件选型

模块	型号	关键参数	接口方式
主控MCU	STM32H743VI	480MHz Cortex-M7，双精度FPU，1MB RAM，硬件浮点加速，支持CMSIS-DSP库	核心控制器
麦克风阵列	ICS-43434×4	MEMS数字麦克风，SNR>65dB，灵敏度-26dBFS，I2S/TDM接口，支持同步采样	I2S（TDM模式，4通道）
音频ADC	PCM1808（可选）	24位立体声ADC，SNR>100dB，112dB动态范围，I2S接口	I2S（与麦克风二选一）
音频DAC	PCM5102A	32位立体声DAC，SNR>112dB，THD<-93dB，I2S接口	I2S（PA4-PA7）
功放模块	TPA6130A2	25mW/32Ω耳机驱动，THD<0.01%，I2C音量控制	I2C（PB6/PB7）
显示模块	OLED 12864（I2C）	0.96寸，显示SNR提升、分离状态、VAD状态	I2C1（复用总线）
存储模块	W25Q256（32MB Flash）	存储分离前后的语音数据，用于离线分析/调试	SPI1（PA5-PA7+PA4）
电源模块	3.7V/2000mAh锂电池+TPS7A8100	低压差LDO，噪声<10μVRMS，为模拟电路提供纯净电源	三级稳压（7.4V→5V→3.3V）

2. 硬件电路设计要点

2.1 麦克风阵列布局

采用线性阵列（2个麦克风）或平面十字阵列（4个麦克风），间距d=5cm：

俯视图（4麦克风十字阵列）：
        MIC3
         ↑
    ← MIC1 → MIC2
         ↓
        MIC4

间距：MIC1-MIC2 = 5cm，MIC3-MIC4 = 5cm

对于双麦克风方案（简化版）：

• 间距5cm，利用时延差（TDOA）辅助FastICA收敛
• I2S/TDM模式同步采样，保证通道相位一致

2.2 核心电路连接

STM32H743最小系统
├── I2S/TDM音频输入（SAI1）
│   ├── SCK = PB10
│   ├── FS  = PB9
│   ├── SD1 = PC3（MIC1数据）
│   ├── SD2 = PC4（MIC2数据）
│   ├── SD3 = PC5（MIC3数据，可选）
│   └── SD4 = PC6（MIC4数据，可选）
├── I2S音频输出（SAI2）
│   ├── SCK = PI1
│   ├── FS  = PI0
│   ├── SD  = PB15
│   └── MCLK= PI2
├── 存储（W25Q256）
│   └── SPI1（PA5=SCK，PA6=MISO，PA7=MOSI，PA4=CS）
└── 显示（OLED）
    └── I2C1（PB6=SCL，PB7=SDA）

2.3 抗干扰设计

• 模拟/数字地隔离：麦克风模拟地与STM32数字地通过磁珠（600Ω@100MHz）单点连接
• 电源净化：模拟电路（麦克风/ADC/DAC）使用独立LDO（TPS7A8100），输入端并联10μF钽电容
• 时钟树优化：I2S主时钟由STM32内部PLL产生，避免外部晶振引入抖动
• 信号走线：音频走线等长，包地处理，远离数字信号线

三、FastICA算法原理

1. 盲源分离模型

混合模型：
$$X(t)=A\cdot S(t)$$

其中：

• $X(t)\in {\mathbb{R}}^{m\times 1}$：观测信号向量（m个麦克风）
• $S(t)\in {\mathbb{R}}^{n\times 1}$：源信号向量（n个独立声源）
• $A\in {\mathbb{R}}^{m\times n}$：混合矩阵（未知）

分离目标：寻找分离矩阵 $W$，使得：
$$Y(t)=W\cdot X(t)\approx S(t)$$

2. FastICA固定点迭代算法

FastICA的核心思想是通过最大化负熵（Negentropy） 来寻找独立分量。负熵定义为：
$$J(y)=H(y_{\text{Gaussian}})-H(y)$$

其中 $H(y)$ 为微分熵。

FastICA迭代公式（牛顿法求解）：
wnew=E{xg(wTx)}−E{g′(wTx)}w\mathbf{w}_{new} = E\{ \mathbf{x}g(\mathbf{w}^T\mathbf{x}) \} - E\{ g'(\mathbf{w}^T\mathbf{x}) \}\mathbf{w}wnew​=E{xg(wTx)}−E{g′(wTx)}w
$${\mathbf{w}}_{normalized}=\frac{{\mathbf{w}}_{new}}{\Vert {\mathbf{w}}_{new}\Vert }$$

其中 $g(u)$ 为对比函数（通常使用 $g_1(u)=u^3$ 或 $g_2(u)=u\exp (-u^2/2)$）。

完整FastICA算法流程：

1. 数据预处理：去均值 + PCA白化（协方差矩阵特征值分解）
2. For k = 1 to n_components:
   a. 随机初始化权重向量 w_k（单位范数）
   b. Repeat:
      i. 计算期望：E1 = E[x·g(w_k^T·x)]
      ii. 计算期望：E2 = E[g'(w_k^T·x)]
      iii. 更新：w_new = E1 - E2·w_k
      iv. 正交化：w_new = w_new - Σ_{j<k}(w_new·w_j)w_j
      v. 归一化：w_new = w_new / ||w_new||
      vi. 检查收敛：if ||w_new - w_k|| < ε, break
      vii. w_k = w_new
3. 得到分离矩阵 W = [w_1, w_2, ..., w_k]^T
4. 分离信号：y_k = w_k^T·x

四、软件设计与核心代码

1. 系统架构（FreeRTOS + CMSIS-DSP）

采用FreeRTOS多任务 + CMSIS-DSP硬件加速，划分6个核心任务（优先级从高到低）：

任务	优先级	功能
音频采集任务	5	I2S DMA双缓冲采集，25ms分帧
预处理任务	4	去均值、PCA白化、加Hamming窗
FastICA任务	3	固定点迭代分离独立语音源
语音增强任务	3	谱减法去残留噪声、维纳滤波
音频输出任务	2	I2S DMA播放增强后的语音
VAD/低功耗任务	1	语音活动检测，无语音时休眠

2. 核心代码实现（基于HAL库 + CMSIS-DSP）

2.1 数据结构与全局定义

#include "arm_math.h"
#include "stm32h7xx_hal.h"

// ========== 系统参数 ==========
#define SAMPLE_RATE     16000       // 16kHz采样率
#define FRAME_LEN       400        // 每帧采样点数（25ms）
#define FRAME_SHIFT     160        // 帧移（10ms）
#define FFT_SIZE        512        // FFT点数（补零到512）
#define NUM_MICS        2         // 麦克风数量
#define NUM_SOURCES     2         // 分离出的源数量
#define ICA_MAX_ITER   200       // FastICA最大迭代次数
#define ICA_EPSILON    1e-6      // 收敛阈值

// ========== 数据结构 ==========
// 帧数据结构体
typedef struct {
    float32_t mic1[FRAME_LEN];   // 麦克风1数据
    float32_t mic2[FRAME_LEN];   // 麦克风2数据
} AudioFrame_t;

// FastICA上下文
typedef struct {
    float32_t X[NUM_MICS][FRAME_LEN];      // 观测信号（白化后）
    float32_t W[NUM_SOURCES][NUM_MICS];    // 分离矩阵
    float32_t Y[NUM_SOURCES][FRAME_LEN];   // 分离出的源信号
    arm_matrix_instance_f32 mat_X;          // 观测矩阵
    arm_matrix_instance_f32 mat_W;          // 分离矩阵
    arm_matrix_instance_f32 mat_Y;          // 分离信号矩阵
} FastICA_Context_t;

FastICA_Context_t ica_ctx;

// 音频环形缓冲区
QueueHandle_t audio_in_queue;
QueueHandle_t audio_out_queue;

2.2 预处理：去均值 + PCA白化

#include "preprocessing.h"

// 计算均值并去均值
void RemoveMean(float32_t *data, uint16_t len) {
    float32_t mean;
    uint16_t i;
    
    // 计算均值
    mean = 0.0f;
    for (i = 0; i < len; i++) {
        mean += data[i];
    }
    mean /= (float32_t)len;
    
    // 减去均值
    for (i = 0; i < len; i++) {
        data[i] -= mean;
    }
}

// PCA白化（Whitening）
// 目的：使数据的协方差矩阵为单位矩阵，简化ICA计算
// 步骤：1) 计算协方差矩阵 2) 特征值分解 3) 白化变换
void PCA_Whitening(float32_t X[NUM_MICS][FRAME_LEN], 
                   float32_t X_white[NUM_MICS][FRAME_LEN]) {
    arm_matrix_instance_f32 mat_X, mat_XT, mat_C, mat_eigvec, mat_eigval;
    float32_t X_T[FRAME_LEN][NUM_MICS];
    float32_t C[NUM_MICS][NUM_MICS];      // 协方差矩阵
    float32_t eigvec[NUM_MICS][NUM_MICS]; // 特征向量
    float32_t eigval[NUM_MICS];            // 特征值
    float32_t temp[NUM_MICS][FRAME_LEN];
    uint16_t i, j, k;
    
    // 1. 计算协方差矩阵 C = (1/N) * X·X^T
    // 转置：X_T = X^T
    for (i = 0; i < NUM_MICS; i++) {
        for (j = 0; j < FRAME_LEN; j++) {
            X_T[j][i] = X[i][j];
        }
    }
    
    // 矩阵乘法：C = X·X^T
    arm_mat_init_f32(&mat_X, NUM_MICS, FRAME_LEN, (float32_t*)X);
    arm_mat_init_f32(&mat_XT, FRAME_LEN, NUM_MICS, (float32_t*)X_T);
    arm_mat_init_f32(&mat_C, NUM_MICS, NUM_MICS, (float32_t*)C);
    arm_mat_mult_f32(&mat_X, &mat_XT, &mat_C);
    
    // 除以N并乘以2（因为协方差公式）
    for (i = 0; i < NUM_MICS; i++) {
        for (j = 0; j < NUM_MICS; j++) {
            C[i][j] /= (float32_t)FRAME_LEN;
        }
    }
    
    // 2. 特征值分解（使用CMSIS-DSP的矩阵函数）
    // 注意：标准CMSIS-DSP不直接支持特征值分解
    // 这里使用简化的幂迭代法求主特征值和特征向量
    // 实际应用中建议预计算白化矩阵或使用第三方库
    
    // 简化版本：对角加载的白化
    float32_t diag_load = 1e-6f;
    for (i = 0; i < NUM_MICS; i++) {
        C[i][i] += diag_load;
    }
    
    // 3. 白化变换：X_white = E·D^(-1/2)·E^T·X
    // 简化为：X_white[i] = X[i] / sqrt(eigval[i])
    // 对于2麦克风情况，可以直接计算
    float32_t scale1 = 1.0f / sqrtf(C[0][0]);
    float32_t scale2 = 1.0f / sqrtf(C[1][1]);
    
    for (j = 0; j < FRAME_LEN; j++) {
        X_white[0][j] = X[0][j] * scale1;
        X_white[1][j] = X[1][j] * scale2;
    }
    
    // 正交化（使各通道不相关）
    float32_t dot_product = 0.0f;
    for (j = 0; j < FRAME_LEN; j++) {
        dot_product += X_white[0][j] * X_white[1][j];
    }
    
    for (j = 0; j < FRAME_LEN; j++) {
        X_white[1][j] -= (dot_product / (float32_t)FRAME_LEN) * X_white[0][j];
    }
}

2.3 FastICA核心算法（固定点迭代）

#include "fastica.h"

// 对比函数及其导数
// g1(u) = u^3, g1'(u) = 3u^2
// g2(u) = u·exp(-u^2/2), g2'(u) = (1-u^2)·exp(-u^2/2)
#define G_FUNC_TYPE 2  // 1=g1, 2=g2

#if G_FUNC_TYPE == 1
    #define G_FUNC(u)     ((u)*(u)*(u))
    #define G_DERIV(u)   (3.0f*(u)*(u))
#elif G_FUNC_TYPE == 2
    #define G_FUNC(u)     ((u)*expf(-0.5f*(u)*(u)))
    #define G_DERIV(u)   ((1.0f-(u)*(u))*expf(-0.5f*(u)*(u)))
#endif

// FastICA单分量分离
// 输入：白化后的观测信号 X[NUM_MICS][FRAME_LEN]
// 输入/输出：权重向量 w[NUM_MICS]（输入初始值，输出最优值）
// 输出：分离的源信号 y[FRAME_LEN]
uint8_t FastICA_SingleComponent(float32_t X[NUM_MICS][FRAME_LEN],
                               float32_t w[NUM_MICS],
                               float32_t y[FRAME_LEN]) {
    float32_t w_old[NUM_MICS];
    float32_t w_new[NUM_MICS];
    float32_t temp[FRAME_LEN];
    float32_t ex1, ex2;  // 期望值
    float32_t norm;
    uint16_t iter, i, j;
    
    for (iter = 0; iter < ICA_MAX_ITER; iter++) {
        // 保存旧权重
        for (i = 0; i < NUM_MICS; i++) {
            w_old[i] = w[i];
        }
        
        // 1. 计算 E{x·g(w^T·x)}
        for (j = 0; j < FRAME_LEN; j++) {
            // 计算 u = w^T·x
            float32_t u = 0.0f;
            for (i = 0; i < NUM_MICS; i++) {
                u += w[i] * X[i][j];
            }
            temp[j] = G_FUNC(u);
        }
        
        // 计算期望值 ex1 = E{temp}
        ex1 = 0.0f;
        for (j = 0; j < FRAME_LEN; j++) {
            ex1 += temp[j];
        }
        ex1 /= (float32_t)FRAME_LEN;
        
        // 2. 计算 E{g'(w^T·x)}
        for (j = 0; j < FRAME_LEN; j++) {
            float32_t u = 0.0f;
            for (i = 0; i < NUM_MICS; i++) {
                u += w[i] * X[i][j];
            }
            temp[j] = G_DERIV(u);
        }
        
        ex2 = 0.0f;
        for (j = 0; j < FRAME_LEN; j++) {
            ex2 += temp[j];
        }
        ex2 /= (float32_t)FRAME_LEN;
        
        // 3. 更新权重：w_new = E{x·g(w^T·x)} - E{g'(w^T·x)}·w
        for (i = 0; i < NUM_MICS; i++) {
            float32_t ex1_x = 0.0f;
            for (j = 0; j < FRAME_LEN; j++) {
                float32_t u = 0.0f;
                for (uint16_t k = 0; k < NUM_MICS; k++) {
                    u += w[k] * X[k][j];
                }
                ex1_x += X[i][j] * G_FUNC(u);
            }
            ex1_x /= (float32_t)FRAME_LEN;
            w_new[i] = ex1_x - ex2 * w[i];
        }
        
        // 4. 正交化（与其他已分离的权重正交）
        for (uint16_t k = 0; k < iter; k++) {
            float32_t dot = 0.0f;
            for (i = 0; i < NUM_MICS; i++) {
                dot += w_new[i] * ica_ctx.W[k][i];
            }
            for (i = 0; i < NUM_MICS; i++) {
                w_new[i] -= dot * ica_ctx.W[k][i];
            }
        }
        
        // 5. 归一化
        norm = 0.0f;
        for (i = 0; i < NUM_MICS; i++) {
            norm += w_new[i] * w_new[i];
        }
        norm = sqrtf(norm);
        for (i = 0; i < NUM_MICS; i++) {
            w_new[i] /= norm;
        }
        
        // 6. 检查收敛
        float32_t diff = 0.0f;
        for (i = 0; i < NUM_MICS; i++) {
            float32_t d = w_new[i] - w_old[i];
            diff += d * d;
        }
        diff = sqrtf(diff);
        
        // 更新权重
        for (i = 0; i < NUM_MICS; i++) {
            w[i] = w_new[i];
        }
        
        if (diff < ICA_EPSILON) {
            break;  // 收敛
        }
    }
    
    // 计算分离的源信号：y = w^T·X
    for (j = 0; j < FRAME_LEN; j++) {
        y[j] = 0.0f;
        for (i = 0; i < NUM_MICS; i++) {
            y[j] += w[i] * X[i][j];
        }
    }
    
    return (iter < ICA_MAX_ITER) ? 1 : 0;  // 1=收敛，0=未收敛
}

// FastICA多分量分离（完整算法）
uint8_t FastICA_Process(float32_t X[NUM_MICS][FRAME_LEN],
                        float32_t Y[NUM_SOURCES][FRAME_LEN]) {
    uint8_t converged;
    uint16_t k, i;
    
    // 初始化分离矩阵（单位矩阵）
    for (k = 0; k < NUM_SOURCES; k++) {
        for (i = 0; i < NUM_MICS; i++) {
            ica_ctx.W[k][i] = (k == i) ? 1.0f : 0.0f;
        }
    }
    
    // 对每个源依次分离
    for (k = 0; k < NUM_SOURCES; k++) {
        converged = FastICA_SingleComponent(X, ica_ctx.W[k], Y[k]);
        if (!converged) {
            // 未收敛，使用当前最佳估计
            // 可以继续迭代或使用其他初始化
        }
    }
    
    return 1;  // 成功
}

2.4 语音增强：谱减法

#include "spectral_subtraction.h"
#include "arm_math.h"

// 汉宁窗系数
const float32_t hamming_window[FRAME_LEN] = {
    // 预先计算的25ms汉宁窗系数
    // w[n] = 0.54 - 0.46·cos(2πn/(N-1))
    // 实际工程中应使用数组初始化
};

// 应用汉宁窗
void ApplyHammingWindow(float32_t *frame) {
    uint16_t i;
    for (i = 0; i < FRAME_LEN; i++) {
        frame[i] *= (0.54f - 0.46f * cosf(2.0f * PI * i / (FRAME_LEN - 1)));
    }
}

// 谱减法语音增强
// 原理：|Y_enhanced|^2 = |Y|^2 - α·|N|^2，其中α为过减因子
void SpectralSubtraction(float32_t *signal, float32_t *enhanced,
                       float32_t alpha, float32_t beta) {
    float32_t fft_in[FFT_SIZE];
    float32_t fft_out[FFT_SIZE * 2];  // 复数输出（实部+虚部）
    float32_t magnitude[FFT_SIZE / 2 + 1];
    float32_t phase[FFT_SIZE / 2 + 1];
    float32_t mag_sq[FFT_SIZE / 2 + 1];
    float32_t noise_est[FFT_SIZE / 2 + 1];
    float32_t enhanced_mag[FFT_SIZE / 2 + 1];
    static uint8_t first_frame = 1;
    uint16_t i;
    
    // 1. 补零到FFT_SIZE
    for (i = 0; i < FRAME_LEN; i++) {
        fft_in[i] = signal[i];
    }
    for (i = FRAME_LEN; i < FFT_SIZE; i++) {
        fft_in[i] = 0.0f;
    }
    
    // 2. FFT变换
    arm_cfft_instance_f32 S;
    arm_cfft_init_f32(&S, FFT_SIZE);
    arm_cfft_f32(&S, fft_in, 0, 1);
    
    // 3. 计算幅度和相位
    arm_cmplx_mag_f32(fft_in, magnitude, FFT_SIZE / 2 + 1);
    
    for (i = 0; i < FFT_SIZE / 2 + 1; i++) {
        phase[i] = atan2f(fft_in[2*i+1], fft_in[2*i]);
        mag_sq[i] = magnitude[i] * magnitude[i];
    }
    
    // 4. 噪声估计（前5帧取平均，或使用VAD检测无声段）
    if (first_frame) {
        for (i = 0; i < FFT_SIZE / 2 + 1; i++) {
            noise_est[i] = mag_sq[i];
        }
        first_frame = 0;
    } else {
        // 指数平滑更新噪声谱
        for (i = 0; i < FFT_SIZE / 2 + 1; i++) {
            noise_est[i] = 0.95f * noise_est[i] + 0.05f * mag_sq[i];
        }
    }
    
    // 5. 谱减：|Y'|^2 = max(|Y|^2 - α·|N|^2, β·|Y|^2)
    for (i = 0; i < FFT_SIZE / 2 + 1; i++) {
        float32_t subtracted = mag_sq[i] - alpha * noise_est[i];
        float32_t floor = beta * mag_sq[i];
        enhanced_mag[i] = sqrtf(fmaxf(subtracted, floor));
    }
    
    // 6. 重建信号（保持相位不变）
    for (i = 0; i < FFT_SIZE / 2 + 1; i++) {
        fft_in[2*i]   = enhanced_mag[i] * cosf(phase[i]);  // 实部
        fft_in[2*i+1] = enhanced_mag[i] * sinf(phase[i]);  // 虚部
    }
    
    // 7. 逆FFT
    arm_cfft_f32(&S, fft_in, 1, 1);  // 逆变换
    
    // 8. 取前FRAME_LEN个点（去除补零部分）
    for (i = 0; i < FRAME_LEN; i++) {
        enhanced[i] = fft_in[2*i] / FFT_SIZE;  // 逆FFT需要除以N
    }
}

2.5 音频采集任务（I2S DMA双缓冲）

#include "audio_capture.h"

// DMA双缓冲区
float32_t dma_buf0[NUM_MICS][FRAME_LEN];
float32_t dma_buf1[NUM_MICS][FRAME_LEN];
volatile uint8_t dma_buf_sel = 0;
volatile uint8_t frame_ready = 0;

// I2S初始化（SAI1，TDM模式，2通道）
void I2S_Capture_Init(void) {
    SAI_HandleTypeDef hsai;
    DMA_HandleTypeDef hdma_sai_rx;
    
    __HAL_RCC_SAI1_CLK_ENABLE();
    __HAL_RCC_DMA1_CLK_ENABLE();
    
    // SAI配置：TDM模式，16位，16kHz，2通道
    hsai.Instance = SAI1_Block_A;
    hsai.Init.AudioMode      = SAI_MODEMASTER_TX;
    hsai.Init.Synchro        = SAI_ASYNCHRONOUS;
    hsai.Init.OutputDrive    = SAI_OUTPUTDRIVE_DISABLE;
    hsai.Init.NoDivider      = SAI_MASTERDIVIDER_DISABLE;
    hsai.Init.FIFOThreshold  = SAI_FIFOTHRESHOLD_1QF;
    hsai.Init.AudioFrequency = SAI_AUDIO_FREQUENCY_16K;
    hsai.Init.SynchroExt     = SAI_SYNCEXT_DISABLE;
    hsai.Init.CompandingMode = SAI_NOCOMPANDING;
    hsai.Init.TriState       = SAI_OUTPUT_NOTRELEASED;
    HAL_SAI_Init(&hsai);
    
    // DMA配置：双缓冲循环模式
    hdma_sai_rx.Instance = DMA1_Stream0;
    hdma_sai_rx.Init.Channel = DMA_CHANNEL_0;
    hdma_sai_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_sai_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_sai_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_sai_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
    hdma_sai_rx.Init.MemDataAlignment = DMA_MDATATAALIGN_HALFWORD;
    hdma_sai_rx.Init.Mode = DMA_CIRCULAR;
    hdma_sai_rx.Init.Priority = DMA_PRIORITY_HIGH;
    hdma_sai_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    HAL_DMA_Init(&hdma_sai_rx);
    
    // 启动DMA双缓冲
    HAL_SAI_Receive_DMA(&hsai, (uint8_t*)dma_buf0, FRAME_LEN * NUM_MICS);
}

// DMA传输完成回调（双缓冲切换）
void HAL_SAI_RxCpltCallback(SAI_HandleTypeDef *hsai) {
    dma_buf_sel = 1;  // 切换到buf1
    frame_ready = 1;
}

void HAL_SAI_RxHalfCpltCallback(SAI_HandleTypeDef *hsai) {
    dma_buf_sel = 0;  // 切换到buf0
    frame_ready = 1;
}

// 音频采集任务
void Audio_Capture_Task(void *pvParameters) {
    AudioFrame_t frame;
    float32_t *current_buf;
    
    I2S_Capture_Init();
    
    while (1) {
        // 等待DMA缓冲区就绪
        while (!frame_ready) {
            vTaskDelay(pdMS_TO_TICKS(1));
        }
        frame_ready = 0;
        
        // 获取当前缓冲区
        current_buf = (dma_buf_sel == 0) ? (float32_t*)dma_buf0 : (float32_t*)dma_buf1;
        
        // 转换为浮点并去均值
        for (uint16_t i = 0; i < FRAME_LEN; i++) {
            frame.mic1[i] = (float32_t)((int16_t*)current_buf)[2*i] / 32768.0f;
            frame.mic2[i] = (float32_t)((int16_t*)current_buf)[2*i+1] / 32768.0f;
        }
        
        RemoveMean(frame.mic1, FRAME_LEN);
        RemoveMean(frame.mic2, FRAME_LEN);
        
        // 发送到预处理任务
        xQueueSend(audio_in_queue, &frame, 0);
    }
}

2.6 FastICA分离任务

#include "fastica_task.h"

// FastICA分离任务
void FastICA_Task(void *pvParameters) {
    AudioFrame_t frame;
    float32_t X_white[NUM_MICS][FRAME_LEN];
    float32_t Y[NUM_SOURCES][FRAME_LEN];
    float32_t Y_enhanced[NUM_SOURCES][FRAME_LEN];
    TickType_t start_time, end_time;
    float32_t proc_time_ms;
    
    while (1) {
        // 等待音频帧
        if (xQueueReceive(audio_in_queue, &frame, portMAX_DELAY) == pdPASS) {
            start_time = xTaskGetTickCount();
            
            // 1. PCA白化
            PCA_Whitening((float32_t*[]){frame.mic1, frame.mic2}, X_white);
            
            // 2. FastICA分离
            FastICA_Process(X_white, Y);
            
            // 3. 谱减法增强
            for (uint8_t k = 0; k < NUM_SOURCES; k++) {
                SpectralSubtraction(Y[k], Y_enhanced[k], 3.0f, 0.01f);
            }
            
            end_time = xTaskGetTickCount();
            proc_time_ms = (end_time - start_time) * portTICK_PERIOD_MS;
            
            // 发送到音频输出任务（选择能量最大的源作为输出）
            float32_t energy1 = 0, energy2 = 0;
            for (uint16_t i = 0; i < FRAME_LEN; i++) {
                energy1 += Y_enhanced[0][i] * Y_enhanced[0][i];
                energy2 += Y_enhanced[1][i] * Y_enhanced[1][i];
            }
            
            float32_t *output = (energy1 > energy2) ? Y_enhanced[0] : Y_enhanced[1];
            xQueueSend(audio_out_queue, output, 0);
        }
    }
}

2.7 主程序框架

#include "stm32h7xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"

int main(void) {
    HAL_Init();
    SystemClock_Config();  // 480MHz
    
    // 初始化外设
    MX_GPIO_Init();
    MX_DMA_Init();
    MX_SAI1_Init();      // I2S音频采集
    MX_SAI2_Init();      // I2S音频输出
    MX_I2C1_Init();      // OLED/功放
    MX_SPI1_Init();      // Flash存储
    
    // 初始化模块
    OLED_Init();
    TPA6130_Init();      // 功放初始化
    
    // 创建队列
    audio_in_queue = xQueueCreate(5, sizeof(AudioFrame_t));
    audio_out_queue = xQueueCreate(5, sizeof(float32_t) * FRAME_LEN);
    
    // 创建FreeRTOS任务
    xTaskCreate(Audio_Capture_Task, "AudioCap", 512, NULL, 5, NULL);
    xTaskCreate(Preprocess_Task, "PreProc", 512, NULL, 4, NULL);
    xTaskCreate(FastICA_Task, "FastICA", 1024, NULL, 3, NULL);
    xTaskCreate(SpeechEnhance_Task, "Enhance", 512, NULL, 3, NULL);
    xTaskCreate(Audio_Playback_Task, "AudioPlay", 512, NULL, 2, NULL);
    xTaskCreate(VAD_LowPower_Task, "VAD", 256, NULL, 1, NULL);
    
    vTaskStartScheduler();
    
    while (1);
}

参考代码 基于FastICA盲源分离算法的语音增强系统 www.youwenfan.com/contentcst/133167.html

五、关键技术与优化

1. FastICA算法优化

优化方向	具体措施	效果
CMSIS-DSP硬件加速	使用arm_cfft_f32、arm_mat_mult_f32等硬件优化函数	计算速度提升5-10倍
定点运算优化	关键路径使用Q15/Q31定点格式，减少浮点开销	适合无FPU的低端MCU
批处理模式	累积多帧后批量处理，摊销FFT开销	降低每帧平均延迟
特征值分解优化	2麦克风场景直接解析求解，避免迭代	实时性大幅提升

2. 语音增强效果评估

信噪比（SNR）提升公式：
$$SN{R}_{improvement}=SN{R}_{out}-SN{R}_{in}=10{\log }_{10}{\left(\frac{\sum s^2}{\sum n^2}\right)}_{out}-10{\log }_{10}{\left(\frac{\sum s^2}{\sum n^2}\right)}_{in}$$

典型性能指标：

场景	输入SNR	输出SNR	SNR提升
安静办公室	20dB	28dB	+8dB
嘈杂餐厅	-5dB	8dB	+13dB
会议室回声	5dB	15dB	+10dB

3. 低功耗设计

• VAD语音活动检测：短时能量+过零率检测，无语音时暂停FastICA计算
• 动态帧长：安静环境用40ms帧长，嘈杂环境用25ms帧长
• 模块休眠：无语音时关闭功放、降低主频至120MHz

六、系统调试与扩展

1. 调试步骤

阶段	操作	工具
硬件调试	测量麦克风I2S波形、时钟抖动	示波器、逻辑分析仪
算法验证	采集已知混合信号（人工混合），验证分离效果	MATLAB/Python对比分析
实时测试	双麦克风采集混合语音，听分离效果	耳机监听、PESQ客观评分
性能测试	测量处理延迟、CPU占用率、内存使用	STM32CubeMonitor、串口打印

2. 扩展功能

• 多通道扩展：从2麦克风扩展到4/6/8麦克风阵列，实现空间滤波（波束成形）
• 深度学习增强：集成轻量级DNN模型（如CRN、WaveNet），替代传统谱减法
• 回声消除（AEC）：添加自适应滤波（NLMS/APA），消除播放回声
• 自动增益控制（AGC）：根据语音能量自动调节输出音量
• 语音识别前端：输出增强后的语音至ASR引擎，提升识别率

七、总结

基于STM32H743与FastICA算法的语音增强系统通过双/多麦克风阵列采集混合语音，PCA白化+FastICA固定点迭代实现盲源分离，谱减法进一步抑制残留噪声，软件充分利用CMSIS-DSP硬件加速确保实时性。