embedded/Core/Src/main.c

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file           : main.c
 * @brief          : Main program body
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2025 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "lfs.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include "periph.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
SPI_HandleTypeDef hspi2;

TIM_HandleTypeDef htim1;

UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart2_rx;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_SPI2_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_TIM1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

#include "at45db041.h"
#include <stdint.h>
#include <stdio.h>
#include <string.h>

extern UART_HandleTypeDef huart2;
extern SPI_HandleTypeDef hspi2;

// int _write(int file, char *ptr, int len) {
//   HAL_UART_Transmit(&huart2, (uint8_t *)ptr, len, HAL_MAX_DELAY);
//   return len;
// }

int __io_putchar(int ch) {
  // Write character to ITM ch.0
  ITM_SendChar(ch);
  return (ch);
}

// ---- Audio ----

#include <stdbool.h>

static uint8_t buf1[256];
static uint8_t buf2[256];
static volatile uint8_t *play_buf = buf1;
static volatile uint8_t *fill_buf = buf2;
static volatile uint16_t buf_idx = 0;
static volatile bool refill_needed = false;
static uint16_t num_pages = 4;
static uint16_t play_page = 0;

void play_audio(void);

void play_audio(void) {
  // Reconfigure TIM1 for PWM audio: 8-bit resolution, ~250 kHz PWM freq, ~8 kHz
  // sample rate with repetition System clock is 64 MHz (from HSI * 16)
  htim1.Init.Period = 255; // ARR = 255 for 8-bit PWM
  htim1.Init.RepetitionCounter =
      30; // RCR = 30 for division by 31 (64M / 256 / 31 ≈ 8064 Hz)
  HAL_TIM_Base_Init(&htim1); // Re-init with new parameters
  TIM1->CCR1 = 128; // Initial duty cycle (center for unsigned 8-bit PCM)

  // Ensure PA8 is configured for TIM1_CH1 PWM
  // This is already done in HAL_TIM_MspPostInit(&htim1);

  // Pre-fill both buffers with first two pages
  at45db_wait_ready();
  at45db_read(0, buf1, 256);
  at45db_wait_ready();
  at45db_read(1, buf2, 256);
  play_page = 2;
  play_buf = buf1;
  fill_buf = buf2;
  buf_idx = 0;
  refill_needed = false;

  // Start PWM and base timer with update interrupts
  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
  HAL_TIM_Base_Start_IT(&htim1);
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
  if (htim == &htim1) {
    // Assume 8-bit unsigned PCM samples
    uint8_t sample = play_buf[buf_idx++];
    TIM1->CCR1 = sample; // Update PWM duty cycle

    if (buf_idx == 256) {
      // Swap buffers
      volatile uint8_t *temp = play_buf;
      play_buf = fill_buf;
      fill_buf = temp;
      buf_idx = 0;
      refill_needed = true;
    }
  }
}

/* New test function to generate a 1 kHz square wave for 5 seconds */
void test_audio_output(void)
{
    printf("Starting audio test: 1 kHz square wave for 5 seconds\n");

    // Configure TIM1 for PWM: 8-bit resolution, ~8 kHz update rate
    htim1.Init.Period = 255;  // 8-bit PWM
    htim1.Init.RepetitionCounter = 30;  // ~8 kHz (64M / 256 / 31 ≈ 8064 Hz)
    HAL_TIM_Base_Init(&htim1);

    // Generate a 1 kHz square wave (toggle every 4 samples at 8 kHz = 2 kHz transitions = 1 kHz tone)
    uint32_t start_time = HAL_GetTick();
    uint8_t sample = 0;
    uint16_t sample_count = 0;

    HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
    HAL_TIM_Base_Start_IT(&htim1);

    while (HAL_GetTick() - start_time < 5000) // Run for 5 seconds
    {
        if (htim1.Instance->SR & TIM_SR_UIF) // Check for update event
        {
            sample_count++;
            if (sample_count % 4 == 0) // Toggle every 4 samples (8 kHz / 4 = 2 kHz transitions)
            {
                sample = (sample == 255) ? 0 : 255; // Square wave: 0 or 255
            }
            TIM1->CCR1 = sample;
            htim1.Instance->SR &= ~TIM_SR_UIF; // Clear update flag
        }
    }

    // Stop PWM and timer
    HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
    HAL_TIM_Base_Stop(&htim1);
    printf("Audio test completed\n");
}

// ---- Audio ----

#define UART_CHUNK_SIZE 256
#define FILE_SIZE_BYTES 2

static uint8_t rx_size_buf[FILE_SIZE_BYTES];
static uint8_t rx_data[UART_CHUNK_SIZE];

static uint16_t total_size = 0;
static uint16_t received = 0;
static uint16_t current_page = 0;

static uint8_t audio_idx = 0;

void uart_receive_file(void);
void print_hex_dump(uint8_t *data, uint32_t length, uint32_t offset);

void print_hex_dump(uint8_t *data, uint32_t length, uint32_t offset) {
  const uint32_t bytes_per_line = 16;

  for (uint32_t i = 0; i < length; i += bytes_per_line) {
    // Печатаем адрес
    printf("%08lX: ", offset + i);

    // Печатаем hex байты
    for (uint32_t j = 0; j < bytes_per_line; j++) {
      if (i + j < length) {
        printf("%02X ", data[i + j]);
      } else {
        printf("   "); // Пробелы для выравнивания
      }

      // Разделитель посередине
      if (j == 7) {
        printf(" ");
      }
    }

    printf("\r\n");
  }
}

void uart_receive_file(void) {
  // 1️⃣ Сначала получаем длину файла (2 байта)
  HAL_UART_Receive(&huart2, rx_size_buf, FILE_SIZE_BYTES, HAL_MAX_DELAY);
  total_size = (rx_size_buf[1] << 8) | rx_size_buf[0];

  printf("File size: %u bytes\n", total_size);

  // 2️⃣ Принимаем и сразу записываем на флеш
  received = 0;
  current_page = 0;

  while (received < total_size) {
    uint16_t remaining = total_size - received;
    uint16_t chunk =
        (remaining >= UART_CHUNK_SIZE) ? UART_CHUNK_SIZE : remaining;
    printf("Page (%u bytes)\n", chunk);

    // Получаем кусок файла
    if (HAL_UART_Receive(&huart2, rx_data, chunk, HAL_MAX_DELAY) == HAL_OK) {
      // Если меньше 256 байт, добиваем нулями
      if (chunk < UART_CHUNK_SIZE)
        memset(rx_data + chunk, 0xFF, UART_CHUNK_SIZE - chunk);

      // Пишем на флеш в текущую страницу
      at45db_wait_ready();
      at45db_write_page(current_page, rx_data);
      at45db_wait_ready();
      printf("Page %u written (%u bytes)\n", current_page, chunk);

      received += chunk;
      current_page++;
    } else {
      printf("UART receive error\n");
      break;
    }
  }

  printf("✅ File received and written to flash!\n");

  uint8_t at45db_buffer[256] = {0};

  printf("Data read from flash:\r\n");
  for (int page = 0; page < current_page; page++) {
    at45db_wait_ready();
    at45db_read(page, at45db_buffer, sizeof(at45db_buffer));
    at45db_wait_ready();

    printf("\r\n=== Page %d ===\r\n", page);
    print_hex_dump(at45db_buffer, sizeof(at45db_buffer), page * 256);
  }
  printf("\r\n");
}


// --- ФИКСЫ ДРАЙВЕРА ---

// Принудительное отключение защиты
void at45db_disable_protection_local(void) {
    uint8_t cmd[4] = {0x3D, 0x2A, 0x7F, 0x9A};
    at45db_wait_ready();
    FLASH_CS_ENABLE();
    HAL_SPI_Transmit(&hspi2, cmd, 4, HAL_MAX_DELAY);
    FLASH_CS_DISABLE();
}

// Исправленное стирание (сдвиг 8 для 256-байтных страниц)
void at45db_erase_page_fixed(uint16_t page) {
    uint8_t cmd[4];
    uint32_t addr = (uint32_t)page << 8; // <--- ВАЖНО: сдвиг 8

    cmd[0] = 0x81; // Page Erase
    cmd[1] = (addr >> 16) & 0xFF;
    cmd[2] = (addr >> 8) & 0xFF;
    cmd[3] = addr & 0xFF;

    FLASH_CS_ENABLE();
    HAL_SPI_Transmit(&hspi2, cmd, 4, HAL_MAX_DELAY);
    FLASH_CS_DISABLE();
}

// Исправленная запись (сдвиг 8)
void at45db_write_page_fixed(uint16_t page, const uint8_t *data) {
    uint8_t cmd[4];
    uint32_t addr = (uint32_t)page << 8; // <--- ВАЖНО: сдвиг 8

    // 1. Загрузка данных в Буфер 1
    cmd[0] = 0x84;
    cmd[1] = 0; cmd[2] = 0; cmd[3] = 0;
    FLASH_CS_ENABLE();
    HAL_SPI_Transmit(&hspi2, cmd, 4, HAL_MAX_DELAY);
    HAL_SPI_Transmit(&hspi2, (uint8_t*)data, 256, HAL_MAX_DELAY);
    FLASH_CS_DISABLE();

    // 2. Прошивка Буфера 1 в Память с встроенным стиранием
    cmd[0] = 0x83;
    cmd[1] = (addr >> 16) & 0xFF;
    cmd[2] = (addr >> 8) & 0xFF;
    cmd[3] = addr & 0xFF;

    at45db_wait_ready(); // Ждем, пока буфер освободится (хотя он быстрый)
    FLASH_CS_ENABLE();
    HAL_SPI_Transmit(&hspi2, cmd, 4, HAL_MAX_DELAY);
    FLASH_CS_DISABLE();
}

// --- LFS CALLBACKS ---

int user_flash_read(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size) {
    // Вычисляем абсолютный адрес
    uint32_t addr = (block * c->block_size) + off;

    uint8_t cmd[5];
    cmd[0] = 0x0B; // High Frequency Read
    cmd[1] = (addr >> 16) & 0xFF;
    cmd[2] = (addr >> 8) & 0xFF;
    cmd[3] = addr & 0xFF;
    cmd[4] = 0x00; // Dummy byte

    at45db_wait_ready(); // Обязательно ждем готовности перед CS

    FLASH_CS_ENABLE();
    if (HAL_SPI_Transmit(&hspi2, cmd, 5, HAL_MAX_DELAY) != HAL_OK) {
        FLASH_CS_DISABLE();
        return LFS_ERR_IO; // Возвращаем ошибку, чтобы LFS не завис
    }
    if (HAL_SPI_Receive(&hspi2, (uint8_t*)buffer, size, HAL_MAX_DELAY) != HAL_OK) {
        FLASH_CS_DISABLE();
        return LFS_ERR_IO;
    }
    FLASH_CS_DISABLE();

    return LFS_ERR_OK; // 0 = Успех
}

int user_flash_prog(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size) {
    // 1 блок (2048) = 8 страниц (по 256)
    uint32_t abs_page = (block * 8) + (off / 256);

    at45db_wait_ready();
    at45db_write_page_fixed((uint16_t)abs_page, (const uint8_t*)buffer);
    at45db_wait_ready();

    // DEBUG: Проверка записи (верификация)
    /*
    uint8_t check_buf[256];
    user_flash_read(c, block, off, check_buf, 256);
    if (memcmp(buffer, check_buf, 256) != 0) {
        printf("VERIFY FAILED at Block %ld Page %ld\r\n", block, abs_page);
        return LFS_ERR_IO;
    }
    */
    return LFS_ERR_OK;
}

int user_flash_erase(const struct lfs_config *c, lfs_block_t block) {
    uint16_t start_page = block * 8;
    for (int i = 0; i < 8; i++) {
        at45db_wait_ready();
        at45db_erase_page_fixed(start_page + i);
    }
    at45db_wait_ready();
    return LFS_ERR_OK;
}

int user_flash_sync(const struct lfs_config *c) {
    at45db_wait_ready();
    return LFS_ERR_OK;
}
/* USER CODE END 0 */

/**
 * @brief  The application entry point.
 * @retval int
 */
int main(void) {
  /* USER CODE BEGIN 1 */


  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick.
   */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_SPI2_Init();
  MX_USART2_UART_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */

  test_audio_output();

  at45db_init();

  // 1. Отключаем защиту (на всякий случай делаем это всегда при старте)
//  at45db_disable_protection_local();

  // 2. Проверяем размер страницы
  if (at45db_get_page_size() != 256) {
      printf("Configuring 256-byte mode...\r\n");
      at45db_page_size_conf(2);
      printf("PLEASE POWER CYCLE DEVICE!\r\n");
      while(1);
  }

  // 3. Конфиг LFS
  static uint8_t lfs_read_buf[256];
  static uint8_t lfs_prog_buf[256];
  static uint8_t lfs_lookahead_buf[32];

  lfs_t lfs;
  struct lfs_config cfg = {
      .context = NULL,
      .read  = user_flash_read,
      .prog  = user_flash_prog,
      .erase = user_flash_erase,
      .sync  = user_flash_sync,

      // ИЗМЕНЕНИЯ ЗДЕСЬ:
      .read_size = 256,         // Было 1. Ставим 256 (размер страницы)
      .prog_size = 256,         // Должно совпадать с read_size для AT45DB
      .block_size = 2048,       // 8 страниц по 256 байт
      .block_count = 256,       // 4 Mbit
      .cache_size = 256,        // Размер кэша = размер страницы
      .lookahead_size = 32,
      .block_cycles = 500,

      .read_buffer = lfs_read_buf,
      .prog_buffer = lfs_prog_buf,
      .lookahead_buffer = lfs_lookahead_buf,
  };

  // 4. Монтирование
  int err = lfs_mount(&lfs, &cfg);
  if (err) {
      printf("Mount failed (%d). Formatting...\r\n", err);
      err = lfs_format(&lfs, &cfg);
      if (err) {
          printf("Format failed (%d)!\r\n", err);
          // Если здесь ошибка, значит защита не снялась или SPI глючит
//          Error_Handler();
      }
      err = lfs_mount(&lfs, &cfg);
  }

  if (!err) {
      printf("LFS Mounted!\r\n");
      // Тестовая запись
      lfs_file_t file;
      uint32_t boot_count = 0;
      lfs_file_open(&lfs, &file, "boot_count", LFS_O_RDWR | LFS_O_CREAT);
      lfs_file_read(&lfs, &file, &boot_count, sizeof(boot_count));
      boot_count++;
      lfs_file_rewind(&lfs, &file);
      lfs_file_write(&lfs, &file, &boot_count, sizeof(boot_count));
      lfs_file_close(&lfs, &file);
      printf("Boot count: %lu\r\n", boot_count);
  }


  uart_receive_file();

 play_audio();

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1) {
   if (refill_needed) {
     // Refill the inactive buffer with the next page
     at45db_wait_ready();
     at45db_read(play_page, (uint8_t *)fill_buf,
                 256);                        // Cast to non-const if needed
     play_page = (play_page + 1) % num_pages; // Loop back for continuous play
     refill_needed = false;
   }

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void) {
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
   * in the RCC_OscInitTypeDef structure.
   */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL16;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
   */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK |
                                RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK) {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_TIM1;
  PeriphClkInit.Tim1ClockSelection = RCC_TIM1CLK_HCLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) {
    Error_Handler();
  }
}

/**
 * @brief SPI2 Initialization Function
 * @param None
 * @retval None
 */
static void MX_SPI2_Init(void) {

  /* USER CODE BEGIN SPI2_Init 0 */

  /* USER CODE END SPI2_Init 0 */

  /* USER CODE BEGIN SPI2_Init 1 */

  /* USER CODE END SPI2_Init 1 */
  /* SPI2 parameter configuration*/
  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 7;
  hspi2.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi2.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  if (HAL_SPI_Init(&hspi2) != HAL_OK) {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI2_Init 2 */

  /* USER CODE END SPI2_Init 2 */
}

/**
 * @brief TIM1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_TIM1_Init(void) {

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 0;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 65535;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK) {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK) {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK) {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK) {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.BreakFilter = 0;
  sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;
  sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
  sBreakDeadTimeConfig.Break2Filter = 0;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK) {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */
  HAL_TIM_MspPostInit(&htim1);
}

/**
 * @brief USART2 Initialization Function
 * @param None
 * @retval None
 */
static void MX_USART2_UART_Init(void) {

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  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;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK) {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */
}

/**
 * Enable DMA controller clock
 */
static void MX_DMA_Init(void) {

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
}

/**
 * @brief GPIO Initialization Function
 * @param None
 * @retval None
 */
static void MX_GPIO_Init(void) {
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  /* USER CODE BEGIN MX_GPIO_Init_1 */
  /* USER CODE END MX_GPIO_Init_1 */

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : PB6 */
  GPIO_InitStruct.Pin = GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* USER CODE BEGIN MX_GPIO_Init_2 */
  /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
 * @brief  This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void) {
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1) {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef USE_FULL_ASSERT
/**
 * @brief  Reports the name of the source file and the source line number
 *         where the assert_param error has occurred.
 * @param  file: pointer to the source file name
 * @param  line: assert_param error line source number
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t line) {
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line
     number, ex: printf("Wrong parameters value: file %s on line %d\r\n", file,
     line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */