```c
/* USER CODE BEGIN Header */
/*
 * STM32 NUCLEO-C031C6
 *
 * PWM Generation:
 * PA8  -> TIM1_CH1 -> 100Hz
 * PA6  -> TIM3_CH1 -> 500Hz
 *
 * Input Capture:
 * PA0  -> TIM2_CH1
 * PA1  -> TIM2_CH2
 *
 * Loopback:
 * PA8 -> PA0
 * PA6 -> PA1
 */
/* USER CODE END Header */

#include "main.h"
#include <stdio.h>

/* Private variables ---------------------------------------------------------*/

TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3;

UART_HandleTypeDef huart2;

/* USER CODE BEGIN PV */

uint32_t IC1_Val1 = 0;
uint32_t IC1_Val2 = 0;
uint32_t IC1_Diff = 0;
uint8_t IC1_First = 0;

uint32_t IC2_Val1 = 0;
uint32_t IC2_Val2 = 0;
uint32_t IC2_Diff = 0;
uint8_t IC2_First = 0;

float freq1 = 0;
float freq2 = 0;

#define TIMER_CLOCK    1000000.0f

/* USER CODE END PV */

void SystemClock_Config(void);

static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);

static void MX_TIM1_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM3_Init(void);

/* USER CODE BEGIN PFP */

int __io_putchar(int ch);

/* USER CODE END PFP */

int main(void)
{
  HAL_Init();

  SystemClock_Config();

  MX_GPIO_Init();

  MX_USART2_UART_Init();

  MX_TIM1_Init();
  MX_TIM2_Init();
  MX_TIM3_Init();

  /* Start PWM */

  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);

  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);

  /* Start Input Capture */

  HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_1);

  HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_2);

  while (1)
  {
    printf("CH1 Frequency = %.2f Hz    ", freq1);

    printf("CH2 Frequency = %.2f Hz\r\n", freq2);

    HAL_Delay(1000);
  }
}

/* -------------------------------------------------------------------------- */
/* INPUT CAPTURE CALLBACK */
/* -------------------------------------------------------------------------- */

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
  /* ---------------- CHANNEL 1 ---------------- */

  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)
  {
    if (IC1_First == 0)
    {
      IC1_Val1 = HAL_TIM_ReadCapturedValue(htim,
                                           TIM_CHANNEL_1);

      IC1_First = 1;
    }
    else
    {
      IC1_Val2 = HAL_TIM_ReadCapturedValue(htim,
                                           TIM_CHANNEL_1);

      if (IC1_Val2 > IC1_Val1)
      {
        IC1_Diff = IC1_Val2 - IC1_Val1;
      }
      else
      {
        IC1_Diff =
        (0xFFFF - IC1_Val1 + 1) + IC1_Val2;
      }

      freq1 = TIMER_CLOCK / IC1_Diff;

      IC1_First = 0;
    }
  }

  /* ---------------- CHANNEL 2 ---------------- */

  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
  {
    if (IC2_First == 0)
    {
      IC2_Val1 = HAL_TIM_ReadCapturedValue(htim,
                                           TIM_CHANNEL_2);

      IC2_First = 1;
    }
    else
    {
      IC2_Val2 = HAL_TIM_ReadCapturedValue(htim,
                                           TIM_CHANNEL_2);

      if (IC2_Val2 > IC2_Val1)
      {
        IC2_Diff = IC2_Val2 - IC2_Val1;
      }
      else
      {
        IC2_Diff =
        (0xFFFF - IC2_Val1 + 1) + IC2_Val2;
      }

      freq2 = TIMER_CLOCK / IC2_Diff;

      IC2_First = 0;
    }
  }
}

/* -------------------------------------------------------------------------- */
/* TIM1 INIT -> 100Hz PWM */
/* PA8 -> TIM1_CH1 */
/* -------------------------------------------------------------------------- */

static void MX_TIM1_Init(void)
{
  TIM_OC_InitTypeDef sConfigOC = {0};

  htim1.Instance = TIM1;

  htim1.Init.Prescaler = 479;

  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;

  htim1.Init.Period = 999;

  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

  htim1.Init.RepetitionCounter = 0;

  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

  HAL_TIM_PWM_Init(&htim1);

  sConfigOC.OCMode = TIM_OCMODE_PWM1;

  sConfigOC.Pulse = 500;

  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

  HAL_TIM_PWM_ConfigChannel(&htim1,
                             &sConfigOC,
                             TIM_CHANNEL_1);

  HAL_TIM_MspPostInit(&htim1);
}

/* -------------------------------------------------------------------------- */
/* TIM3 INIT -> 500Hz PWM */
/* PA6 -> TIM3_CH1 */
/* -------------------------------------------------------------------------- */

static void MX_TIM3_Init(void)
{
  TIM_OC_InitTypeDef sConfigOC = {0};

  htim3.Instance = TIM3;

  htim3.Init.Prescaler = 95;

  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;

  htim3.Init.Period = 999;

  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

  HAL_TIM_PWM_Init(&htim3);

  sConfigOC.OCMode = TIM_OCMODE_PWM1;

  sConfigOC.Pulse = 500;

  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

  HAL_TIM_PWM_ConfigChannel(&htim3,
                             &sConfigOC,
                             TIM_CHANNEL_1);

  HAL_TIM_MspPostInit(&htim3);
}

/* -------------------------------------------------------------------------- */
/* TIM2 INPUT CAPTURE */
/* PA0 -> TIM2_CH1 */
/* PA1 -> TIM2_CH2 */
/* -------------------------------------------------------------------------- */

static void MX_TIM2_Init(void)
{
  TIM_IC_InitTypeDef sConfigIC = {0};

  htim2.Instance = TIM2;

  htim2.Init.Prescaler = 47;

  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

  htim2.Init.Period = 0xFFFF;

  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

  HAL_TIM_IC_Init(&htim2);

  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;

  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;

  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;

  sConfigIC.ICFilter = 0;

  HAL_TIM_IC_ConfigChannel(&htim2,
                            &sConfigIC,
                            TIM_CHANNEL_1);

  HAL_TIM_IC_ConfigChannel(&htim2,
                            &sConfigIC,
                            TIM_CHANNEL_2);
}

/* -------------------------------------------------------------------------- */
/* UART2 INIT */
/* -------------------------------------------------------------------------- */

static void MX_USART2_UART_Init(void)
{
  huart2.Instance = USART2;

  huart2.Init.BaudRate = 115200;

  huart2.Init.WordLength = UART_WORDLENGTH_8B;

  huart2.Init.StopBits = UART_STOPBITS_1;

  huart2.Init.Parity = UART_PARITY_NONE;

  huart2.Init.Mode = UART_MODE_TX_RX;

  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;

  huart2.Init.OverSampling = UART_OVERSAMPLING_16;

  HAL_UART_Init(&huart2);
}

/* -------------------------------------------------------------------------- */
/* GPIO INIT */
/* -------------------------------------------------------------------------- */

static void MX_GPIO_Init(void)
{
  __HAL_RCC_GPIOA_CLK_ENABLE();
}

/* -------------------------------------------------------------------------- */
/* CLOCK CONFIG */
/* 48MHz */
/* -------------------------------------------------------------------------- */

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;

  RCC_OscInitStruct.HSIState = RCC_HSI_ON;

  RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;

  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;

  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;

  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;

  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV1;

  RCC_OscInitStruct.PLL.PLLN = 12;

  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;

  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;

  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;

  HAL_RCC_OscConfig(&RCC_OscInitStruct);

  RCC_ClkInitStruct.ClockType =
      RCC_CLOCKTYPE_HCLK
    | RCC_CLOCKTYPE_SYSCLK
    | RCC_CLOCKTYPE_PCLK1;

  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  HAL_RCC_ClockConfig(&RCC_ClkInitStruct,
                      FLASH_LATENCY_2);
}

/* -------------------------------------------------------------------------- */
/* UART PRINTF REDIRECT */
/* -------------------------------------------------------------------------- */

int __io_putchar(int ch)
{
  HAL_UART_Transmit(&huart2,
                    (uint8_t *)&ch,
                    1,
                    HAL_MAX_DELAY);

  return ch;
}

/* -------------------------------------------------------------------------- */
/* IRQ HANDLER */
/* -------------------------------------------------------------------------- */

void TIM2_IRQHandler(void)
{
  HAL_TIM_IRQHandler(&htim2);
}
```