嵌入式 ANC：STM32 实战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

void DFSDM_Init(void) {
    hdfsdm1_Channel0.Instance = DFSDM1_Channel0;
    hdfsdm1_Channel0.Init.OutputClock.Divider = 32;
    hdfsdm1_Channel0.Init.OutputClock.Selection = DFSDM_CHANNEL_OUTPUT_CLOCK_AUDIO;
    hdfsdm1_Channel0.Init.Input.Multiplexer = DFSDM_CHANNEL_EXTERNAL_INPUTS;
    hdfsdm1_Channel0.Init.Input.DataPacking = DFSDM_CHANNEL_STANDARD_MODE;
    hdfsdm1_Channel0.Init.Input.Pins = DFSDM_CHANNEL_SAME_CHANNEL_PINS;
    hdfsdm1_Channel0.Init.SerialInterface.Type = DFSDM_CHANNEL_SPI_RISING;
    hdfsdm1_Channel0.Init.SerialInterface.SpiClock = DFSDM_CHANNEL_SPI_CLOCK_INTERNAL;
    hdfsdm1_Channel0.Init.Awd.FilterOrder = DFSDM_CHANNEL_FASTSINC_ORDER;
    hdfsdm1_Channel0.Init.Awd.Oversampling = 64;
    HAL_DFSDM_ChannelInit(&hdfsdm1_Channel0);

    hdfsdm1_Filter0.Instance = DFSDM1_Filter0;
    hdfsdm1_Filter0.Init.RegularParam.Trigger = DFSDM_FILTER_SW_TRIGGER;
    hdfsdm1_Filter0.Init.RegularParam.FastMode = ENABLE;
    hdfsdm1_Filter0.Init.SincOrder = DFSDM_FILTER_SINC3_ORDER;
    hdfsdm1_Filter0.Init.Oversampling = 64;
    hdfsdm1_Filter0.Init.IntOversampling = 1;
    HAL_DFSDM_FilterInit(&hdfsdm1_Filter0);

    HAL_DFSDM_FilterConfigRegChannel(&hdfsdm1_Filter0,
                                     DFSDM_CHANNEL_0,
                                     DFSDM_CONTINUOUS_CONV_ON);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include "arm_math.h"
#include "cmsis_os.h"

#define BLOCK_SIZE      64
#define FILTER_TAPS     64
#define NUM_TAPS_STAGE  32

typedef struct {
    arm_fir_instance_f32 fir_inst;
    float32_t state[FILTER_TAPS + BLOCK_SIZE - 1];
    float32_t coeffs[FILTER_TAPS];
} CMSIS_FIR_Filter;

typedef struct {
    CMSIS_FIR_Filter w_filter;
    CMSIS_FIR_Filter s_filter;
    float32_t mu;
    float32_t x_buf[BLOCK_SIZE];
    float32_t e_buf[BLOCK_SIZE];
} FXLMS_CMSIS;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

void fxlms_cmsis_init(FXLMS_CMSIS *fx, float32_t *s_hat, uint32_t s_len) {
    arm_fir_init_f32(&fx->w_filter.fir_inst, FILTER_TAPS,
                     fx->w_filter.coeffs, fx->w_filter.state, BLOCK_SIZE);
    memset(fx->w_filter.coeffs, 0, sizeof(fx->w_filter.coeffs));
    arm_fir_init_f32(&fx->s_filter.fir_inst, s_len,
                     s_hat, fx->s_filter.state, BLOCK_SIZE);
    fx->mu = 0.0005f;
}

void fxlms_cmsis_process(FXLMS_CMSIS *fx, float32_t *x_ref,
                         float32_t *e_mic, float32_t *output,
                         uint32_t block_size) {
    float32_t x_filtered[BLOCK_SIZE];
    float32_t y_output[BLOCK_SIZE];

    arm_fir_f32(&fx->w_filter.fir_inst, x_ref, y_output, block_size);
    arm_fir_f32(&fx->s_filter.fir_inst, x_ref, x_filtered, block_size);

    for (uint32_t n = 0; n < block_size; n++) {
        float32_t norm_factor = x_filtered[n] * x_filtered[n] + 1e-6f;
        float32_t step = fx->mu / norm_factor;
        for (uint32_t k = 0; k < FILTER_TAPS; k++) {
            if (n >= k) {
                fx->w_filter.coeffs[k] += step * e_mic[n] * x_filtered[n - k];
            }
        }
    }
    memcpy(output, y_output, block_size * sizeof(float32_t));
}

1

w_k(n+1) = w_k(n) + μ · e(n) · x'(n-k)

1

μ(n) = μ₀ / (||x'(n)||² + ε)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

void ANC_Processing_Task(void *argument) {
    FXLMS_CMSIS fxlms;
    float32_t s_hat[NUM_TAPS_STAGE] = { /* 离线辨识结果 */ };
    fxlms_cmsis_init(&fxlms, s_hat, NUM_TAPS_STAGE);

    int16_t raw_ref[BLOCK_SIZE];
    int16_t raw_err[BLOCK_SIZE];
    float32_t f_ref[BLOCK_SIZE], f_err[BLOCK_SIZE];
    float32_t output[BLOCK_SIZE];
    int16_t dac_output[BLOCK_SIZE];

    for (;;) {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        arm_q15_to_float(raw_ref, f_ref, BLOCK_SIZE);
        arm_q15_to_float(raw_err, f_err, BLOCK_SIZE);
        fxlms_cmsis_process(&fxlms, f_ref, f_err, output, BLOCK_SIZE);
        arm_float_to_q15(output, dac_output, BLOCK_SIZE);
        HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1, (uint32_t*)dac_output,
                          BLOCK_SIZE, DAC_ALIGN_12B_L);
    }
}

1
2
3
4
5

// DMA 乒乓缓冲——active_buf 在 0 和 1 之间交替
HAL_DFSDM_FilterRegConvStart_DMA(&hdfsdm1_Filter0,
                                 ping_pong_buf[active_buf],
                                 BLOCK_SIZE);
// CPU 同时处理 ping_pong_buf[1 - active_buf] 中的数据

1
2
3
4
5
6
7

typedef struct {
    uint8_t  header[2];     // 0xAA 0x55
    uint8_t  type;          // 0x01=音频数据, 0x02=控制命令
    uint16_t seq;
    uint16_t len;
    int16_t  samples[];
} __attribute__((packed)) AudioFrame;