Урок №32. Цифровая фильтрация сигнала на STM32F411
В этом уроке разберём базовый принцип цифровой фильтрации на микроконтроллере STM32F411.
Сформируем полезный синусоидальный сигнал, добавим к нему две высокочастотные помехи, а затем пропустим полученный сигнал через цифровой фильтр нижних частот.
Все сигналы формируются непосредственно внутри STM32F411. Результаты фильтрации передаются по UART, после чего их можно вывести на график.
1. Создаём рабочий сигнал и накладываем на него помехи
В примере используются следующие параметры:
Полезный сигнал: 200 Гц Первая помеха: 600 Гц Вторая помеха: 900 Гц Частота дискретизации: 4000 Гц Фильтр: ФНЧ 4-го порядка Частота среза фильтра: 300 Гц
Полезный сигнал находится на частоте 200 Гц, а помехи — на частотах 600 Гц и 900 Гц.
Задача фильтра — пропустить полезный сигнал 200 Гц и подавить высокочастотные составляющие 600 и 900 Гц.
2. Формирование чистого сигнала
Полезный сигнал формируется строкой:
clean = sinf(2.0f * PI_F * 200.0f * t);
Это обычная синусоида частотой 200 Гц.
clean(t) = sin(2π · 200 · t)
3. Добавление помехи
К полезному сигналу добавляем две дополнительные синусоиды:
noise = 0.35f * sinf(2.0f * PI_F * 600.0f * t)
+ 0.25f * sinf(2.0f * PI_F * 900.0f * t);
Первая помеха имеет частоту 600 Гц и амплитуду 0.35.
Вторая помеха имеет частоту 900 Гц и амплитуду 0.25.
После этого формируем общий входной сигнал:
input = clean + noise;
То есть:
input(t) = полезный сигнал 200 Гц + помеха 600 Гц + помеха 900 Гц
На графике получается синусоида, на которую наложена высокочастотная рябь.
4. Зачем нужна частота дискретизации
Цифровой фильтр работает не с непрерывным сигналом, а с отдельными отсчётами.
В нашем примере:
Fs = 4000 Гц
Значит новый отсчёт обрабатывается каждые:
1 / 4000 = 0.00025 с = 250 мкс
Для этого используется TIM2, который формирует прерывание с частотой 4000 Гц.
В каждом прерывании создаётся новый отсчёт сигнала и сразу передаётся в цифровой фильтр.
5. Почему частота среза 300 Гц
Нам необходимо оставить сигнал 200 Гц, но подавить 600 и 900 Гц.
Полезный сигнал: 200 Гц Частота среза: 300 Гц Помеха: 600 Гц и 900 Гц
Если установить частоту среза слишком низко, фильтр начнёт ослаблять полезный сигнал.
Если установить её слишком высоко, помеха 600 Гц будет подавляться хуже.
Для данного учебного примера частота среза 300 Гц располагается между полезным сигналом 200 Гц и первой помехой 600 Гц.
6. Какой фильтр используется
В программе используется цифровой фильтр нижних частот Butterworth 4-го порядка.
200 Гц — должен пройти 600 Гц — должен подавиться 900 Гц — должен подавиться ещё сильнее
Фильтр Butterworth имеет ровную амплитудно-частотную характеристику в полосе пропускания, поэтому в ней отсутствует выраженная амплитудная рябь.
7. Почему фильтр 4-го порядка
Чем выше порядок фильтра, тем быстрее растёт подавление сигнала после частоты среза.
Фильтр 1-го порядка для данного примера был бы слишком слабым.
Фильтр 2-го порядка уже работает лучше, но помеха 600 Гц подавлялась бы слабее.
Фильтр 4-го порядка можно удобно реализовать в виде двух последовательных секций второго порядка.
8. Что такое biquad-секция
Секция второго порядка часто называется biquad.
Она работает по формуле:
y[n] = b0·x[n] + b1·x[n-1] + b2·x[n-2] - a1·y[n-1] - a2·y[n-2]
Здесь:
x[n] — текущий входной отсчёт x[n-1] — предыдущий входной отсчёт x[n-2] — входной отсчёт два шага назад y[n] — текущий выходной отсчёт y[n-1] — предыдущий выходной отсчёт y[n-2] — выходной отсчёт два шага назад b0, b1, b2 — коэффициенты прямой части фильтра a1, a2 — коэффициенты обратной связи
Фильтр использует не только текущий входной отсчёт, но и предыдущие значения входа и выхода. То есть цифровой IIR-фильтр имеет внутреннее состояние — память.
9. Алгоритм работы одной секции фильтра
1. Получаем новый входной отсчёт x[n]. 2. Считаем новый выход y[n]. 3. x[n-1] переносим в x[n-2]. 4. Текущий x[n] сохраняем как x[n-1]. 5. y[n-1] переносим в y[n-2]. 6. Текущий y[n] сохраняем как y[n-1]. 7. Возвращаем y[n].
В программе это реализовано функцией:
static float Biquad_Process(BiquadFilter *f, float x)
{
float y;
y = f->b0 * x
+ f->b1 * f->x1
+ f->b2 * f->x2
- f->a1 * f->y1
- f->a2 * f->y2;
f->x2 = f->x1;
f->x1 = x;
f->y2 = f->y1;
f->y1 = y;
return y;
}
10. Как получается фильтр 4-го порядка
Одна biquad-секция — это фильтр второго порядка.
Для получения 4-го порядка используем две секции последовательно:
input ↓ biquad section 1 ↓ biquad section 2 ↓ filtered
В программе:
static float LowPassFilter_Process(float x)
{
float y;
y = Biquad_Process(&lp_section1, x);
y = Biquad_Process(&lp_section2, y);
return y;
}
11. Коэффициенты фильтра
Коэффициенты рассчитаны для условий:
Fs = 4000 Гц Fc = 300 Гц Тип фильтра = Butterworth Low-pass Порядок = 4
Первая секция:
.b0 = 0.001782610f .b1 = 0.003565220f .b2 = 0.001782610f .a1 = -1.255440470f .a2 = 0.409013780f
Вторая секция:
.b0 = 1.000000000f .b1 = 2.000000000f .b2 = 1.000000000f .a1 = -1.518241840f .a2 = 0.703962660f
Эти коэффициенты относятся именно к выбранным Fs = 4000 Гц и Fc = 300 Гц. При изменении частоты дискретизации, частоты среза или порядка фильтра коэффициенты необходимо пересчитать.
Расчёт коэффициентов в Python
Для расчёта коэффициентов можно использовать Python и библиотеку SciPy.
import numpy as np
from scipy import signal
# Частота дискретизации
Fs = 4000.0
# Частота среза фильтра
Fc = 300.0
# Порядок фильтра
order = 4
# Расчёт Butterworth low-pass фильтра
sos = signal.butter(
order,
Fc,
btype='low',
fs=Fs,
output='sos'
)
print("SOS coefficients:")
print(sos)
print("\nCoefficients for C code:")
for i, section in enumerate(sos):
b0, b1, b2, a0, a1, a2 = section
# Нормирование
b0 = b0 / a0
b1 = b1 / a0
b2 = b2 / a0
a1 = a1 / a0
a2 = a2 / a0
print(f"\nSection {i + 1}:")
print(f".b0 = {b0:.9f}f,")
print(f".b1 = {b1:.9f}f,")
print(f".b2 = {b2:.9f}f,")
print(f".a1 = {a1:.9f}f,")
print(f".a2 = {a2:.9f}f,")
После запуска Python выдаёт коэффициенты двух biquad-секций, которые затем переносим в программу STM32F411.
12. Как работает программа на STM32F411
TIM2 вызывает прерывание 4000 раз в секунду
↓
создаётся чистый сигнал 200 Гц
↓
добавляются помехи 600 Гц и 900 Гц
↓
получается шумный сигнал
↓
сигнал проходит через ФНЧ 4-го порядка
↓
чистый, шумный и отфильтрованный сигналы
выводятся по UART
В UART передаются три значения:
clean_x1000,input_x1000,filtered_x1000
Например:
309,782,1
Это соответствует:
clean = 0.309 input = 0.782 filtered = 0.001
Значения умножаются на 1000, чтобы не использовать вывод типа float через printf.
13. Настройка TIM2
TIM2 создаёт частоту дискретизации 4000 Гц.
SYSCLK = 84 МГц APB1 = 42 МГц TIM2 clock = 84 МГц
Настройки таймера:
Prescaler = 83 Period = 249
Расчёт:
84 000 000 / (83 + 1) = 1 000 000 Гц 1 000 000 / (249 + 1) = 4000 Гц
Прерывание возникает каждые:
1 / 4000 = 250 мкс
14. Настройка UART
Используется USART2 со скоростью:
921600 baud
Настройки терминала:
Baudrate: 921600 Data: 8 bit Parity: None Stop: 1
Параметр UART_DECIMATION определяет, как часто отправляются данные относительно частоты работы фильтра.
UART_DECIMATION = 1 4000 / 1 = 4000 строк в секунду
Если установить:
UART_DECIMATION = 4 4000 / 4 = 1000 строк в секунду
В исходной версии страницы в описании указано значение 4, а в фактическом программном коде — значение 1. Поэтому здесь оба варианта показаны явно.
На выходе получаем график чистого, зашумлённого и отфильтрованного сигналов.
Выходной сигнал немного смещён относительно входного. Для IIR-фильтра это нормально: фильтрация сопровождается фазовым сдвигом.
Программный код STM32F411
Ниже приведены пользовательские секции программы, которые вставляются в проект, созданный в STM32CubeMX / STM32CubeIDE и используемый далее в Keil.
/* USER CODE BEGIN Includes */
#include <math.h>
#include <stdio.h>
#include <string.h>
/* USER CODE END Includes */
/* USER CODE BEGIN PTD */
typedef struct
{
float b0;
float b1;
float b2;
float a1;
float a2;
float x1;
float x2;
float y1;
float y2;
} BiquadFilter;
/* USER CODE END PTD */
/* USER CODE BEGIN PD */
#define FS_HZ 4000.0f
#define PI_F 3.14159265358979323846f
/*
UART_DECIMATION = 1:
filter sample rate = 4000 Hz
UART output rate = 4000 lines/sec
Если потребуется уменьшить поток UART:
UART_DECIMATION = 4
UART output rate = 1000 lines/sec
*/
#define UART_DECIMATION 1
/* USER CODE END PD */
/* USER CODE BEGIN PV */
static BiquadFilter lp_section1 =
{
.b0 = 0.001782610f,
.b1 = 0.003565220f,
.b2 = 0.001782610f,
.a1 = -1.255440470f,
.a2 = 0.409013780f,
.x1 = 0.0f,
.x2 = 0.0f,
.y1 = 0.0f,
.y2 = 0.0f
};
static BiquadFilter lp_section2 =
{
.b0 = 1.000000000f,
.b1 = 2.000000000f,
.b2 = 1.000000000f,
.a1 = -1.518241840f,
.a2 = 0.703962660f,
.x1 = 0.0f,
.x2 = 0.0f,
.y1 = 0.0f,
.y2 = 0.0f
};
volatile int32_t uart_clean_x1000 = 0;
volatile int32_t uart_input_x1000 = 0;
volatile int32_t uart_filtered_x1000 = 0;
volatile uint8_t uart_data_ready = 0;
static uint32_t signal_phase_index = 0;
static uint32_t sample_counter = 0;
/* USER CODE END PV */
/* USER CODE BEGIN PFP */
static void UART_SendString(const char *s);
static int32_t Float_To_X1000(float value);
static void LowPassFilter_Reset(void);
static float Biquad_Process(
BiquadFilter *f,
float x
);
static float LowPassFilter_Process(float x);
static void DSP_ProcessOneSample(void);
/* USER CODE END PFP */
/* USER CODE BEGIN 0 */
static void UART_SendString(const char *s)
{
HAL_UART_Transmit(
&huart2,
(uint8_t *)s,
strlen(s),
HAL_MAX_DELAY
);
}
static int32_t Float_To_X1000(float value)
{
if (value >= 0.0f)
{
return (int32_t)(
value * 1000.0f + 0.5f
);
}
else
{
return (int32_t)(
value * 1000.0f - 0.5f
);
}
}
static void LowPassFilter_Reset(void)
{
lp_section1.x1 = 0.0f;
lp_section1.x2 = 0.0f;
lp_section1.y1 = 0.0f;
lp_section1.y2 = 0.0f;
lp_section2.x1 = 0.0f;
lp_section2.x2 = 0.0f;
lp_section2.y1 = 0.0f;
lp_section2.y2 = 0.0f;
signal_phase_index = 0u;
sample_counter = 0u;
uart_data_ready = 0u;
}
static float Biquad_Process(
BiquadFilter *f,
float x
)
{
float y;
y = f->b0 * x
+ f->b1 * f->x1
+ f->b2 * f->x2
- f->a1 * f->y1
- f->a2 * f->y2;
f->x2 = f->x1;
f->x1 = x;
f->y2 = f->y1;
f->y1 = y;
return y;
}
static float LowPassFilter_Process(float x)
{
float y;
y = Biquad_Process(
&lp_section1,
x
);
y = Biquad_Process(
&lp_section2,
y
);
return y;
}
static void DSP_ProcessOneSample(void)
{
float t;
float clean;
float noise;
float input;
float filtered;
t =
(float)signal_phase_index
/ FS_HZ;
clean =
sinf(
2.0f
* PI_F
* 200.0f
* t
);
noise =
0.35f
* sinf(
2.0f
* PI_F
* 600.0f
* t
)
+
0.25f
* sinf(
2.0f
* PI_F
* 900.0f
* t
);
input =
clean + noise;
filtered =
LowPassFilter_Process(
input
);
signal_phase_index++;
if (
signal_phase_index
>= 4000u
)
{
signal_phase_index = 0u;
}
sample_counter++;
if (
(
sample_counter
% UART_DECIMATION
)
== 0u
)
{
uart_clean_x1000 =
Float_To_X1000(
clean
);
uart_input_x1000 =
Float_To_X1000(
input
);
uart_filtered_x1000 =
Float_To_X1000(
filtered
);
uart_data_ready = 1u;
}
}
void HAL_TIM_PeriodElapsedCallback(
TIM_HandleTypeDef *htim
)
{
if (
htim->Instance
== TIM2
)
{
DSP_ProcessOneSample();
}
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
HAL_Delay(500);
LowPassFilter_Reset();
UART_SendString(
"\r\n"
);
UART_SendString(
"STM32F411 DSP filter\r\n"
);
UART_SendString(
"Fs=4000Hz, clean=200Hz, "
"noise=600Hz+900Hz, "
"LPF Fc=300Hz\r\n"
);
UART_SendString(
"clean_x1000,"
"input_x1000,"
"filtered_x1000\r\n"
);
if (
HAL_TIM_Base_Start_IT(
&htim2
)
!= HAL_OK
)
{
Error_Handler();
}
/* USER CODE END 2 */
/* USER CODE BEGIN WHILE */
while (1)
{
char line[80];
int32_t clean_i = 0;
int32_t input_i = 0;
int32_t filtered_i = 0;
uint8_t ready = 0;
__disable_irq();
ready =
uart_data_ready;
if (ready != 0u)
{
clean_i =
uart_clean_x1000;
input_i =
uart_input_x1000;
filtered_i =
uart_filtered_x1000;
uart_data_ready = 0u;
}
__enable_irq();
if (ready != 0u)
{
snprintf(
line,
sizeof(line),
"%ld,%ld,%ld\r\n",
(long)clean_i,
(long)input_i,
(long)filtered_i
);
UART_SendString(line);
}
/* USER CODE END WHILE */
}
Что мы изучили
- как формируется дискретный сигнал;
- как добавить к полезному сигналу высокочастотную помеху;
- что такое частота дискретизации;
- как выбирается частота среза ФНЧ;
- что такое фильтр Butterworth;
- как работает biquad-секция;
- как собрать фильтр 4-го порядка из двух секций второго порядка;
- как рассчитать коэффициенты с помощью Python и SciPy;
- как запускать обработку сигнала от TIM2 с частотой 4000 Гц;
- как передавать результаты фильтрации по USART2.
В результате полезный сигнал 200 Гц проходит через цифровой фильтр, а высокочастотные составляющие 600 и 900 Гц подавляются.