В этой небольшой статье хочу рассказать вам о различных методах измерения частоты прямоугольного сигнала с помощью микроконтроллера STM32.

В процессе работы над одной из железок возникла необходимость организовать несколько выводов, которые бы измеряли частоту входного сигнала. Опробовав несколько разных вариантов, я решил, что негоже примерам пылиться на задворках диска D и стоит ими поделиться с сообществом. Надеюсь кому-то, находящемся в похожей ситуации, этот материал будет полезен. Материал в первую очередь рассчитан на новичков.

Начальные условия: частота входного сигнала от 0 до 10 кГц. Микроконтроллер STM32F103C8T6, всем известная плата bluepill. Библиотека HAL. Источником сигнала, частота которого будет измеряться, для проверки работоспособности будет служить двухканальный генератор частоты JDS6600. Я буду использовать модуль CH340G (Преобразователь USB - UART) для передачи данных в терминал (terminal v1.9b) для наглядности. В него я буду посылать полученное после обработки значение.

Рассмотрим первый способ – измерение частоты с помощью таймера.

Подключение: Генератор частоты напрямую подключен к выводам микроконтроллера PA0 и PA2. Выводы земли объединены.

Настройка проекта: перейдем в STM32IDE и создаем проект под наш контроллер. После настройки источника тактирования включаем UART для отправки значений:

Частоту тактирования настроил на 64 МГц.

В примере я буду использовать Timer 2. Настроим таймер на обработку сразу двух сигналов:

Канал 1 — это основной (direct) канал, а канал 2 это косвенный (indirect). Косвенный канал не имеет отдельного вывода. Аналогично для канала 3 и 4. Захват частоты происходит следующим образом – первый канал реагирует на передний фронт, и мы фиксируем время начала нового периода. После второй канал фиксирует задний фронт, и мы фиксируем время окончания импульса. Затем первый канал фиксирует начало нового периода / окончание предыдущего. Имея эти три временные точки, можно посчитать длительность периода и скважность. Значение делителя и периода Timer 2:

Значение предделителя определяет шаг, с которым будет считать таймер. Чем меньше шаг, тем точнее результат, но тогда можно столкнуться с тем, что в длительность одного периода таймера не будет помещаться захватываемый сигнал. При частоте тактирования таймера 64 МГц и предделителе = 64 (предделитель в программе выставляется на 1 меньше) получаем, что длительность одного тика таймера равна микросекунде. Период (Counter periode) определяет, до какого значения будет считать таймер до переполнения. В данной задаче лучше его оставить в максимальном значение.

Фильтр входного сигнала (Input Filter) используется для устранения помех и шумов, которые могут возникать на входе таймера. Он позволяет фильтровать входной сигнал и принимать во внимание только стабильные и длительные изменения сигнала, игнорируя кратковременные нежелательные помехи. Если входной сигнал стабилен и не подвержен сильным помехам, можно установить значение фильтра на минимальное или даже отключить его. Однако, при работе с шумными или нестабильными входными сигналами, может потребоваться увеличение значения фильтра для надежной и стабильной работы таймера. Я выставляю Input Filter в максимум. Включим прерывание таймера:

Пишем код: в начале заведем глобальные переменные для хранения длительностей:

volatile uint16_t start1 = 0, end_imp1 = 0, end_per1 = 0, start2 = 0, end_imp2 = 0, end_per2 = 0;

где в переменной start будет храниться значение начала периода, end_imp будет храниться значение конца импульса, end_ per будет храниться значение конца периода. 1 и 2 соответственно CH1+CH2 и CH3+CH4.

volatile uint16_t period1 = 0, fill_factor1 = 0, long_imp1 = 0, period2 = 0, fill_factor2 = 0, long_imp2 = 0;
volatile uint16_t freq1 = 0, freq2 = 0;
volatile uint8_t flag_IC = 0;

Тут будем хранить вычисленные переменные и будем выставлять флаг о том, что пришел сигнал. Далее включим все каналы нашего таймера и заведем массив для отправки по UART:

  /* USER CODE BEGIN 2 */
	HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_1);
	HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_2);
	HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_3);
	HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_4);

После срабатывания прерывания по захвату программа будет попадать в callback (эта функция, которая вызывается после определенного события/прерывания) функцию, которая описана ниже:

/* USER CODE BEGIN 4 */
/*----------------------------------------------------------------------------*/
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	if (htim->Instance == TIM2)
	{
		if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)
		{
			start1 = end_per1;
			end_per1 = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_1);
			end_imp1 = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_2);
		}
		if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3)
		{
			start2 = end_per2;
			end_per2 = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_3);
			end_imp2 = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_4);
		}
		flag_IC = 1;
	}
}

В ней выставляется флаг «flag_IC», по которому будем определять приход новых данных. В отдельной функции будем вычислять значение периода и коэффициента заполнения:

/*----------------------------------------------------------------------------*/
void CALC_FREQ (void)
{
	// длительность периода в импульсах (1 импульс = 1 мкс)
	if (end_per1 > start1) 
	{
		period1 = end_per1 - start1;
		long_imp1 = end_imp1 - start1;
		if (period1 > 0)
		{
			freq1 = 1000000 / period1;
			fill_factor1 = (long_imp1 * 100) / period1;
		}
	}
	if (end_per2 > start2)
	{
		period2 = end_per2 - start2;
		long_imp2 = end_imp2 - start2;
		if (period2 > 0)
		{
			freq2 = 1000000 / period2;
			fill_factor2 = (long_imp2 * 100) / period2;
		}
	}
}

Условие «if (end_per1 > start1)» нужно для того, чтобы не обсчитывать импульсы, которые попадают на переполнение таймера, когда начало периода было в одном цикле таймера, а конец в другом. Но обсчёт такого случая тоже можно реализовать.

В основном цикле отслеживаем значение флага, как только он стал равен единице, вычисляем значение частоты и коэффициента заполнения, после отправляем данные по UART в терминал и сбрасываем значение флага:

if(flag_IC == 1)
	{
		CALC_FREQ();
		snprintf(buff, 80, "Freq 1 = %d fill_factor 1 = %d  Freq 2 = %d fill_factor 2 = %d\r\n", freq1, fill_factor1, freq2, fill_factor2);
		HAL_UART_Transmit_IT(&huart1, buff, strlen(buff));
		HAL_Delay(500);
		flag_IC = 0;
	}

Я запускаю генератор частоты с вот такими настройками:

Оправляем два прямоугольных сигнала с частотой 1кГц и 850 Гц. Теперь посмотрим, что нам пришло на терминал:

В терминале выставляем скорость 115200 и получаем результат. Теперь проверим этот же код, но на динамический сигнал. Я покрутил значение частоты на первом канале от 1 кГц до 8 кГц и обратно с шагом в 1 кГц и вот что получил:

В принципе работает, но в реальных системах частота может менять сильно быстрее, чем я кручу ручку, так что тест с динамическим сигналом правильно считать упрощенным.

Достоинства и недостатки:

Теперь рассмотрим вариант измерения значения частоты с использованием вывода EXTI.

Выводы EXTI (External Interrupt) у микроконтроллеров STM32 предназначены для обработки внешних прерываний от различных источников. EXTI позволяет реагировать на изменения состояния внешних сигналов и генерировать прерывания для обработки этих событий. Логика работы довольно проста – каждый раз, когда приходит импульс, мы по прерыванию будем инкрементировать значение импульсов, а раз в секунду смотреть, сколько импульсов пришло. Так и получим необходимую нам частоту.

Подключение: генератор частоты подключен к выводам PA0 и PA1.

Настройка проекта: В настройках контроллера включаем выводы PA0 и PA1 как выводы EXTI. Также включаем прерывание у них. Прерывание будет срабатывать на восходящий фронт сигнала.

Также надо включить таймер, который будет отсчитывать одну секунду, в прерывании которого мы будем фиксировать нашу входную частоту:

Пишем код:

/* USER CODE BEGIN PV */
volatile uint32_t num_imp1 = 0, num_imp2 = 0;
uint32_t freq1 = 0, freq2 = 0;
volatile uint8_t  flag_timer = 0;

Заводим переменные. Первые две будут инкрементироваться каждый раз, когда приходит импульс. Каждую секунду по прерыванию таймера будет вывешиваться флаг, при изменении которого мы будем фиксировать значение частоты и сбрасывать счетчики импульсов. Вот так будет выглядеть callback по EXTI выводам:

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if (GPIO_Pin == GPIO_PIN_0)
	  num_imp1++;
  if (GPIO_Pin == GPIO_PIN_1)
	  num_imp2++;
} 

И вот так по таймеру:

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
	flag_timer = 1;
	freq1 = num_imp1;
	freq2 = num_imp2;
	num_imp1 = 0;
	num_imp2 = 0;
}

Значение количества импульсов за период сбрасываем каждую секунду. Теперь отправляем значение частоты по UART:

if (flag_timer == 1)
{
	snprintf(buff, 80, "Freq 1 = %d Freq 2 = %d\r\n", freq1, freq2);
	HAL_UART_Transmit_IT(&huart1, buff, strlen(buff));
	flag_timer = 0;
}

Подадим 1 кГц на первый канал и 5 кГц на втором:

Вот результат захвата динамического сигнала (канал ch2 статичный):

Отлично, все работает. Теперь о достоинствах и недостатках:

И последний рассмотренный мною метод – захват с помощью ETR2. При настройке источника тактирования таймера можно выбрать вывод ETR2 (External Trigger Input 2), и тогда таймер в качестве источника тактирования будет использовать внешний источник. На этот вывод будет подаваться замеряемый сигнал.

Реализуем частотомер второго рода. Основной принцип работы частотомера второго рода заключается в сравнении частоты входящего сигнала с частотой, генерируемой внутри прибора, в нашем случае длительность периода внешнего сигнала будет измеряться в кол-ве тиков другого таймера.

Заводим timer 2, который просто считает импульсы с максимально возможной частотой. По приходу первого импульса на ETR2 запускается timer 4. Когда на timer 2 придет, допустим, сотый импульс, мы фиксируем, сколько импульсов насчитал timer 4. Делим это значение на 100 и получаем период захватываемого сигнала. Картинка для чуть лучшего понимания:

Настройка проекта: настроим таймера 2, на который будет подаваться входной сигнал. Считает до 100го импульса, а потом счет сбрасывается и начинается новый период. Именно в этот момент мы будем фиксировать кол-во отсчитанного времени на 100 периодов входного сигнала.

Настройка таймера 4 для отсчета времени:

У обоих таймеров необходимо включить прерывание. Переходим к коду: создаем глобальные переменные:

/* USER CODE BEGIN PV */
volatile uint16_t num_per_tim = 0;    // кол-во прошедших периодов таймера
volatile uint16_t time_tim = 0;       // сюда будем записывать время с таймера, когда при-шел 10 импульс
volatile uint16_t per_tim = 0;        // сюда будем записывать кол-во периодов таймера
volatile uint8_t  flag_data = 0;      // по этому флагу будем отслеживать момент, когда пора считать значение частоты

Создаем callback для обработки данных. Суть в том, что таймер 4 считает с частотой больше частоты входного сигнала и будет много раз переполняться. Кол-во переполнений таймера 4 как раз и будем хранить в переменной num_per_tim, поэтому в callback таймера 4 необходимо каждый раз инкрементировать счетчик периодов таймера. А в callback таймера 2 программа будет попадать, когда пришли все 100 импульсов и будет фиксироваться затраченное количество импульсов таймера 4.

/* USER CODE BEGIN 4 */
/*----------------------------------------------------------------------------*/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	// если таймер досчитал до конца, не получив все 100 импульсов на вход Timer 2 ETR2, то увеличиваем счетчик кол-ва периодов
	if (htim->Instance == TIM4)
		num_per_tim++;
	if (htim->Instance == TIM2)
	{
		time_tim = __HAL_TIM_GET_COUNTER(&htim4);
		per_tim  = num_per_tim;
		num_per_tim = 0;                                   // сброс счетчика периодов
		TIM4->CNT = 0;                                     // сброс счета таймера
		flag_data = 1;
	}
}

Теперь, отслеживая состояние flag_data можно считать частоту:

if (flag_data == 1)
{
	float freq = 0;
	float period = time_tim + per_tim * 65536 + 1;             // период в тиках таймера
	if (period != 0)                                           // на всякий исключим деление на ноль
	{
		period /= 100;                                         // длительность одного периода
		freq = 72000000 / period;
	}
	else freq = 0;
	snprintf(buff, 80, "Freq = %.3f\r\n", freq);
	HAL_UART_Transmit_IT(&huart1, buff, strlen(buff));
	flag_data = 0;
	HAL_Delay(500);
}

В начале вычисляем суммарное потраченное время, а затем делим его на 100 и вуаля, значение частоты готово. Подадим на вывод PA0 сигнал с частотой 10 кГц:

Теоретически, этот метод должен быть с самым большим диапазоном частоты входного сигнала. Попробуем 100 кГц:

Ну и 1 МГц:

Последний результат уже с большой погрешностью, но, тем не менее, работает.

Достоинства и недостатки:

Конечно, тут описаны не все возможные способы измерения частоты входного сигнала, а только несколько, с которыми я столкнулся.  Некоторые из них были проверены только на макете и в реальных задачах могут вести себя отлично от того, что получилось у меня.

Для себя я выбрал вариант с выводами EXTI, так как в устройстве не требуется быстродействие и большая точность, но требуется много каналов захвата. Первый метод мне понравился меньше всех остальных, потому что в остальных вариантах мы получаем сразу некое усредненное значение, что мне подходило намного лучше.

Ссылка на проекты