/* USER CODE BEGIN Header */
/*
 * Main file of M20 custom firmware project
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "config.h"
#if GPS_TYPE == 1
#include "nmea.h"
#elif GPS_TYPE == 2
#include "xm_gps.h"
#endif
#include "adf.h"
#include "fsk4.h"
#include "horus.h"
#include "lps22hb.h"

#include <math.h>
#ifdef DEBUG
#include <stdio.h>
#include <string.h>
#endif
/* 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 ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
uint8_t GpsRxBuffer[GpsRxBuffer_SIZE];
uint16_t GpsBufferCounter = 0;
bool GpsBufferReady = false;

#if GPS_TYPE == 1
NMEA NmeaData;
const static uint8_t GPS_airborne[44] = {
    0xB5, 0x62, 0x06, 0x24, 0x24, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0xD6};
#elif GPS_TYPE == 2
XMDATA GpsData;
#endif

#ifdef GPS_WATCHDOG
struct GpsWatchdogStruct {
  bool PreviousFix;
  bool AfterRestart;
  uint8_t AfterRestartCounter;
  bool TriggerRestart;

#if GPS_TYPE == 2
  uint32_t LastTime;
#endif
} GpsWatchdog;
#endif

uint8_t lps_init;

HorusBinaryPacket HorusPacket;

char HorusCodedBuffer[100]; // TODO: change size
uint16_t HorusCodedLen;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_LPUART1_UART_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_SPI1_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM22_Init(void);
static void MX_ADC_Init(void);
static void MX_IWDG_Init(void);
static void MX_TIM6_Init(void);
/* USER CODE BEGIN PFP */
void GPS_Handler(void);
void LED_Handler(void);
void main_loop(void);
void DelayWithIWDG(uint16_t time);
void GpsAirborne(void);

#ifdef DEBUG
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
   set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */
/**
 * @brief  Retargets the C library printf function to the USART.
 * @param  None
 * @retval None
 */
PUTCHAR_PROTOTYPE {
  /* Place your implementation of fputc here */
  /* e.g. write a character to the EVAL_COM1 and Loop until the end of
   * transmission */
  while (!LL_USART_IsActiveFlag_TXE(USART1)) {
  }
  LL_USART_TransmitData9(USART1, ch);

  return ch;
}
#endif
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void main_loop(void) {
  // LED
#if LED_MODE == 1
  LL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
#endif

#ifdef DEBUG
  // Frame number
  printf("\r\nFrame: %d\r\n", HorusPacket.PacketCount);
#endif

// GPS type 1 data
#if GPS_TYPE == 1
  HorusPacket.Hours = NmeaData.Hours;
  HorusPacket.Minutes = NmeaData.Minutes;
  HorusPacket.Seconds = NmeaData.Seconds;
  HorusPacket.Lat = NmeaData.Lat;
  HorusPacket.Lon = NmeaData.Lon;
  HorusPacket.Speed = (uint8_t)NmeaData.Speed;
  HorusPacket.AscentRate = (int16_t)round(NmeaData.AscentRate * 100.0);
  HorusPacket.Alt = NmeaData.Alt;
  HorusPacket.Sats = NmeaData.Sats;
#ifdef DEBUG
  printf("Fix: %d, Lat: %ld, Lon: %ld, Alt: %d m, Speed: %d km/h, Ascent rate: "
         "%d m/s Satellites: %d, Time: %d:%d:%d\r\n",
         NmeaData.Fix, (uint32_t)(NmeaData.Lat * 10e6),
         (uint32_t)(NmeaData.Lon * 10e6), NmeaData.Alt, NmeaData.Speed,
         (int16_t)round(NmeaData.AscentRate * 100), NmeaData.Sats,
         NmeaData.Hours, NmeaData.Minutes, NmeaData.Seconds);
#endif

// GPS type 2 data
#elif GPS_TYPE == 2
  HorusPacket.Hours = GpsData.Hours;
  HorusPacket.Minutes = GpsData.Minutes;
  HorusPacket.Seconds = GpsData.Seconds;
  HorusPacket.Lat = GpsData.Lat;
  HorusPacket.Lon = GpsData.Lon;
  HorusPacket.Speed = (uint16_t)GpsData.GroundSpeed; // Doesn't work
  HorusPacket.Alt = (uint16_t)GpsData.Alt;
  HorusPacket.Sats = GpsData.Sats;
  HorusPacket.AscentRate = (int16_t)round(GpsData.AscentRate * 100.0);
#ifdef DEBUG
  printf("Fix: %d, Lat: %d, Lon: %d, Alt: %d, Ascent Rate: %d, Ground Speed: "
         "%f, Sats: %d, Time: %d: %d:%d:%d\r\n",
         GpsData.Fix, (int32_t)(GpsData.Lat * 1e6),
         (int32_t)(GpsData.Lon * 1e6), (uint32_t)(GpsData.Alt * 1e6),
         (int16_t)(GpsData.AscentRate * 100.0), GpsData.GroundSpeed,
         GpsData.Sats, GpsData.Time, GpsData.Hours, GpsData.Minutes,
         GpsData.Seconds);
#endif
#endif

  // LPS22HB sensor
  if (lps_init == 0) {
    HorusPacket.Temp = (int8_t)round(LPS22_GetTemp());
    HorusPacket.Press = (uint16_t)round(LPS22_GetPress() * 10.0);
  }
#ifdef DEBUG
  printf("temp: %d, press: %d\r\n", HorusPacket.Temp, HorusPacket.Press);
#endif

  // Bat voltage
  LL_ADC_REG_SetSequencerChannels(ADC1, LL_ADC_CHANNEL_8);
  LL_ADC_REG_StartConversion(ADC1);
  while (LL_ADC_IsActiveFlag_EOC(ADC1) == 0) {
  }
  // ADC voltage: 3.3V, divided by ADC max value 4095 (2^12-1). That gives a
  // range between 0 for 0V and 1 for 3.3V. Than it's multiplied by max
  // variable value: 255, and divided by corresponding voltage: 5V, simplified
  // gives 187/4550 Note: this value will not go higher than 168 corresponding
  // to 3.3V max value of ADC
  HorusPacket.BatVoltage = (LL_ADC_REG_ReadConversionData12(ADC1) * 187) / 4550;
  LL_ADC_ClearFlag_EOS(ADC1);

#ifdef DEBUG
  printf("Bat voltage: %d\r\n", HorusPacket.BatVoltage);
#endif

  // NTC temp reading
  LL_GPIO_SetOutputPin(NTC_36K_GPIO_Port, NTC_36K_Pin);
  LL_mDelay(5);

  LL_ADC_REG_SetSequencerChannels(ADC1, LL_ADC_CHANNEL_14);
  LL_ADC_REG_StartConversion(ADC1);
  while (LL_ADC_IsActiveFlag_EOC(ADC1) == 0) {
  }
  uint16_t temp_adc_raw = LL_ADC_REG_ReadConversionData12(ADC1);
  LL_ADC_ClearFlag_EOS(ADC1);

  LL_GPIO_ResetOutputPin(NTC_36K_GPIO_Port, NTC_36K_Pin);

  // External temp calculating
  // Rntc = Vout * R1 /  Vin - Vout
  float NTC_R = ((temp_adc_raw * 36500) / (4096 - temp_adc_raw));
  float NTC_T = 1 / (-0.000400644 + (0.000490078 * log(NTC_R)) +
                     (-0.000000720 * pow(log(NTC_R), 3))) -
                273.15;
  HorusPacket.ExtTemp = (int16_t)round(NTC_T * 10.0);
#ifdef DEBUG
  printf("NTC: raw: %d, Temp: %d\r\n", temp_adc_raw, HorusPacket.ExtTemp);
#endif

  // Horus checksum
  HorusPacket.Checksum =
      (uint16_t)crc16((char *)&HorusPacket, sizeof(HorusPacket) - 2);
  HorusCodedLen = horus_l2_encode_tx_packet((unsigned char *)HorusCodedBuffer,
                                            (unsigned char *)&HorusPacket,
                                            sizeof(HorusPacket));

#ifdef GPS_WATCHDOG
// Set a flag if we have initial fix.
#if GPS_TYPE == 1
  if (NmeaData.Fix > 1 && NmeaData.Sats > 0) {
    GpsWatchdog.PreviousFix = true;
    GpsWatchdog.AfterRestart = false;
  }
#elif GPS_TYPE == 2
  if (GpsData.Fix > 1 && GpsData.Sats > 0) {
    GpsWatchdog.PreviousFix = true;
    GpsWatchdog.AfterRestart = false;
  }
#endif
  // Check GPS reset conditions only if there was initial fix.
  if (GpsWatchdog.PreviousFix) {
#if GPS_TYPE == 1
    if (NmeaData.Fix > 1 && NmeaData.Sats > 0) {
      /*
        if (NmeaData.AscentRate >= GPS_WATCHDOG_ASCENTRATE) {
          GpsWatchdog.TriggerRestart = true;
        }*/ //disable all gps watchdog checks for now, more testing needed
    }
#elif GPS_TYPE == 2
    if (GpsData.Fix > 1 && GpsData.Sats > 0) {
      // If there is  fix check spoofing specific conditions.
      // Ascent rate
      // printf("%d %d\r\n",(int32_t)GpsData.Time - TIME_PERIOD,
      // GpsWatchdog.LastTime);
      /*if ((int32_t)GpsData.AscentRate >= GPS_WATCHDOG_ASCENTRATE
          || (int32_t)GpsData.AscentRate <= (-1*GPS_WATCHDOG_ASCENTRATE)
          // Time deviation
          || (GpsWatchdog.LastTime != 0 &&
          (((int32_t)GpsData.Time - TIME_PERIOD) - GpsWatchdog.LastTime >
      GPS_WATCHDOG_MAX_D_TIME
          || GpsWatchdog.LastTime - ((int32_t)GpsData.Time - TIME_PERIOD) <
      GPS_WATCHDOG_MAX_D_TIME))) {
        // If conditions match trigger a restart
        GpsWatchdog.TriggerRestart = true;
      }

      GpsWatchdog.LastTime = GpsData.Time;
      // if (GpsData.AscentRate >= GPS_WATCHDOG_ASCENTRATE ||
      //(GpsWatchdog.LastTime != 0 &&
      // (GpsData.Time-TIME_PERIOD-GpsWatchdog.LastTime>GPS_WATCHDOG_MAX_TIME ||
      //
      GpsData.Time-TIME_PERIOD-GpsWatchdog.LastTime<(-1*GPS_WATCHDOG_MAX_TIME))))
      */
    }
#endif
    else if (GpsWatchdog.AfterRestart) {
      // If there is no fix and gps after a restart give it some time before
      // next restart
      GpsWatchdog.AfterRestartCounter++;
      if (GpsWatchdog.AfterRestartCounter >= GPS_WATCHDOG_ARC / TIME_PERIOD) {
        GpsWatchdog.TriggerRestart = true;
      }
    } else {
      GpsWatchdog.TriggerRestart = true;
    }
  }
  // printf("%d %d %d %d\r\n", GpsWatchdog.PreviousFix,
  //       GpsWatchdog.AfterRestart, GpsWatchdog.AfterRestartCounter,
  //       GpsWatchdog.TriggerRestart);

  if (GpsWatchdog.TriggerRestart) {
    LL_GPIO_ResetOutputPin(GPS_ON_GPIO_Port, GPS_ON_Pin); // disable GPS
    DelayWithIWDG(1000);
    LL_GPIO_SetOutputPin(GPS_ON_GPIO_Port, GPS_ON_Pin); // enable GPS
  }
#endif

  // Transmit
  FSK4_start_TX(HorusCodedBuffer, HorusCodedLen);

#ifdef GPS_WATCHDOG
  if (GpsWatchdog.TriggerRestart) {
#if GPS_TYPE == 1
    while (FSK4_is_active()) {
      LL_IWDG_ReloadCounter(IWDG);
      LL_mDelay(100);
    } // Wait for end of transmission (and for GPS module to start).
    LL_LPUART_DisableIT_RXNE(
        LPUART1);  // disable UART RX interrupt to not occure while mode change
    GpsAirborne(); // Send a command to GPS module to change to airborne mode.
    LL_LPUART_EnableIT_RXNE(LPUART1); // reenable UART RX interrupt
    // clear GPS buffer needed?
#endif
    // GPS type 2 doesn't need mode change

    // Reset variables to after restart state
    GpsWatchdog.TriggerRestart = false;
    GpsWatchdog.AfterRestart = true;
    GpsWatchdog.AfterRestartCounter = 0;
    //GpsWatchdog.LastTime = 0;

    HorusPacket.GpsResetCount++;
  }
#endif

  // Packet counter
  HorusPacket.PacketCount++;

// LED
#if LED_MODE == 1
  LL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
#endif
}
/* 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.
   */
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SYSCFG);
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_PWR);

  /* SysTick_IRQn interrupt configuration */
  NVIC_SetPriority(SysTick_IRQn, 3);

  /* 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_LPUART1_UART_Init();
  MX_USART1_UART_Init();
  MX_SPI1_Init();
  MX_TIM2_Init();
  MX_TIM22_Init();
  MX_ADC_Init();
  MX_IWDG_Init();
  MX_TIM6_Init();
  /* USER CODE BEGIN 2 */

  // Power on modules
  LL_GPIO_SetOutputPin(POWER_ON_GPIO_Port, POWER_ON_Pin);
  LL_GPIO_SetOutputPin(GPS_ON_GPIO_Port, GPS_ON_Pin);
  LL_GPIO_SetOutputPin(RADIO_EN_GPIO_Port, RADIO_EN_Pin);
  adf_setup();

  LL_GPIO_SetOutputPin(LED_GPIO_Port, LED_Pin); // LED

  HorusPacket.PayloadID = PAYLOAD_ID;

  HorusPacket.Unused = 32; // number in unused packet space, can be used to identify M20 transmitter durring flight, value is not important

  // Init of LPS22 sensor, try 5 times
  for (uint8_t i = 0; i < 5; i++) {
    lps_init = LPS22_Init();
    if (lps_init == 0)
      break;
  }
#ifdef DEBUG
  printf("LPS init: %d\r\n", lps_init);
#endif

  // ADC init
  LL_ADC_ClearFlag_ADRDY(ADC1);
  LL_ADC_Enable(ADC1);
  while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0) {
  }

  // GPS UART init
  LL_LPUART_Enable(LPUART1);

#if GPS_TYPE == 1
  // u-blox change mode to airborne
  DelayWithIWDG(2000); // Wait for full GPS start
  GpsAirborne(); // Send a command to GPS module to change to airborne mode.
  DelayWithIWDG(100);
#endif

  // GPS UART RX interrupt enable after mode change
  LL_LPUART_EnableIT_RXNE(LPUART1);

  LL_GPIO_ResetOutputPin(LED_GPIO_Port, LED_Pin);

  // main loop timer
  LL_TIM_EnableCounter(TIM22);
  LL_TIM_EnableIT_UPDATE(TIM22);

  // LED timer
  LL_TIM_EnableCounter(TIM6);
  LL_TIM_EnableIT_UPDATE(TIM6);

  /* Interrupt priorites:
   * TIM2 - modulation timer: 0
   * LPUART1 - GPS UART RX: 1
   * TIM22 - main loop: 2
   * TIM6 - LED timer: 3
   * SysTick: 3
   */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1) {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
    LL_IWDG_ReloadCounter(IWDG);
    if (GpsBufferReady) {
#if GPS_TYPE == 1
      ParseNMEA(&NmeaData, GpsRxBuffer);
#elif GPS_TYPE == 2
      parseXMframe(&GpsData, GpsRxBuffer);
#endif
#ifdef DEBUG
#if GPS_TYPE == 1
      printf("Correct gps frames: %d\r\n", NmeaData.Corr);
#endif
#endif
      GpsBufferReady = false;
    }
    LL_mDelay(10);
  }
  /* USER CODE END 3 */
}

/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void) {
  LL_FLASH_SetLatency(LL_FLASH_LATENCY_0);
  while (LL_FLASH_GetLatency() != LL_FLASH_LATENCY_0) {
  }
  LL_PWR_SetRegulVoltageScaling(LL_PWR_REGU_VOLTAGE_SCALE1);
  while (LL_PWR_IsActiveFlag_VOS() != 0) {
  }
  LL_RCC_HSE_Enable();

  /* Wait till HSE is ready */
  while (LL_RCC_HSE_IsReady() != 1) {
  }
  LL_RCC_LSI_Enable();

  /* Wait till LSI is ready */
  while (LL_RCC_LSI_IsReady() != 1) {
  }
  LL_RCC_PLL_ConfigDomain_SYS(LL_RCC_PLLSOURCE_HSE, LL_RCC_PLL_MUL_3,
                              LL_RCC_PLL_DIV_2);
  LL_RCC_PLL_Enable();

  /* Wait till PLL is ready */
  while (LL_RCC_PLL_IsReady() != 1) {
  }
  LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
  LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
  LL_RCC_SetAPB2Prescaler(LL_RCC_APB2_DIV_1);
  LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_PLL);

  /* Wait till System clock is ready */
  while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_PLL) {
  }

  LL_Init1msTick(12000000);

  LL_SetSystemCoreClock(12000000);
  LL_RCC_SetUSARTClockSource(LL_RCC_USART1_CLKSOURCE_SYSCLK);
  LL_RCC_SetLPUARTClockSource(LL_RCC_LPUART1_CLKSOURCE_SYSCLK);
  LL_RCC_ConfigMCO(LL_RCC_MCO1SOURCE_HSE, LL_RCC_MCO1_DIV_1);
}

/**
 * @brief ADC Initialization Function
 * @param None
 * @retval None
 */
static void MX_ADC_Init(void) {

  /* USER CODE BEGIN ADC_Init 0 */

  /* USER CODE END ADC_Init 0 */

  LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
  LL_ADC_InitTypeDef ADC_InitStruct = {0};

  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC1);

  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOC);
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOB);
  /**ADC GPIO Configuration
  PC0   ------> ADC_IN10
  PC4   ------> ADC_IN14
  PB0   ------> ADC_IN8
  */
  GPIO_InitStruct.Pin = PAYLOAD_ADC_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(PAYLOAD_ADC_GPIO_Port, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = NTC_ADC_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(NTC_ADC_GPIO_Port, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = BAT_ADC_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(BAT_ADC_GPIO_Port, &GPIO_InitStruct);

  /* USER CODE BEGIN ADC_Init 1 */

  /* USER CODE END ADC_Init 1 */

  /** Configure Regular Channel
   */
  LL_ADC_REG_SetSequencerChAdd(ADC1, LL_ADC_CHANNEL_8);

  /** Configure Regular Channel
   */
  LL_ADC_REG_SetSequencerChAdd(ADC1, LL_ADC_CHANNEL_10);

  /** Configure Regular Channel
   */
  LL_ADC_REG_SetSequencerChAdd(ADC1, LL_ADC_CHANNEL_14);

  /** Common config
   */
  ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;
  ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;
  ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;
  ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_NONE;
  ADC_REG_InitStruct.Overrun = LL_ADC_REG_OVR_DATA_OVERWRITTEN;
  LL_ADC_REG_Init(ADC1, &ADC_REG_InitStruct);
  LL_ADC_SetSamplingTimeCommonChannels(ADC1, LL_ADC_SAMPLINGTIME_3CYCLES_5);
  LL_ADC_SetOverSamplingScope(ADC1, LL_ADC_OVS_DISABLE);
  LL_ADC_REG_SetSequencerScanDirection(ADC1, LL_ADC_REG_SEQ_SCAN_DIR_FORWARD);
  LL_ADC_SetCommonFrequencyMode(__LL_ADC_COMMON_INSTANCE(ADC1),
                                LL_ADC_CLOCK_FREQ_MODE_HIGH);
  LL_ADC_DisableIT_EOC(ADC1);
  LL_ADC_DisableIT_EOS(ADC1);
  ADC_InitStruct.Clock = LL_ADC_CLOCK_SYNC_PCLK_DIV1;
  ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B;
  ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;
  ADC_InitStruct.LowPowerMode = LL_ADC_LP_MODE_NONE;
  LL_ADC_Init(ADC1, &ADC_InitStruct);

  /* Enable ADC internal voltage regulator */
  LL_ADC_EnableInternalRegulator(ADC1);
  /* Delay for ADC internal voltage regulator stabilization. */
  /* Compute number of CPU cycles to wait for, from delay in us. */
  /* Note: Variable divided by 2 to compensate partially */
  /* CPU processing cycles (depends on compilation optimization). */
  /* Note: If system core clock frequency is below 200kHz, wait time */
  /* is only a few CPU processing cycles. */
  uint32_t wait_loop_index;
  wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US *
                      (SystemCoreClock / (100000 * 2))) /
                     10);
  while (wait_loop_index != 0) {
    wait_loop_index--;
  }
  /* USER CODE BEGIN ADC_Init 2 */
  /* USER CODE END ADC_Init 2 */
}

/**
 * @brief IWDG Initialization Function
 * @param None
 * @retval None
 */
static void MX_IWDG_Init(void) {

  /* USER CODE BEGIN IWDG_Init 0 */

  /* USER CODE END IWDG_Init 0 */

  /* USER CODE BEGIN IWDG_Init 1 */

  /* USER CODE END IWDG_Init 1 */
  LL_IWDG_Enable(IWDG);
  LL_IWDG_EnableWriteAccess(IWDG);
  LL_IWDG_SetPrescaler(IWDG, LL_IWDG_PRESCALER_8);
  LL_IWDG_SetReloadCounter(IWDG, 4095);
  while (LL_IWDG_IsReady(IWDG) != 1) {
  }

  LL_IWDG_ReloadCounter(IWDG);
  /* USER CODE BEGIN IWDG_Init 2 */

  /* USER CODE END IWDG_Init 2 */
}

/**
 * @brief LPUART1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_LPUART1_UART_Init(void) {

  /* USER CODE BEGIN LPUART1_Init 0 */

  /* USER CODE END LPUART1_Init 0 */

  LL_LPUART_InitTypeDef LPUART_InitStruct = {0};

  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_LPUART1);

  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOC);
  /**LPUART1 GPIO Configuration
  PC10   ------> LPUART1_TX
  PC11   ------> LPUART1_RX
  */
  GPIO_InitStruct.Pin = LL_GPIO_PIN_10;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_11;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /* LPUART1 interrupt Init */
  NVIC_SetPriority(LPUART1_IRQn, 1);
  NVIC_EnableIRQ(LPUART1_IRQn);

  /* USER CODE BEGIN LPUART1_Init 1 */
#if GPS_TYPE == 1
  LPUART_InitStruct.BaudRate = 9600;
#elif GPS_TYPE == 2
  LPUART_InitStruct.BaudRate = 38400;
#endif
  /* USER CODE END LPUART1_Init 1 */
  // LPUART_InitStruct.BaudRate = 9600;
  LPUART_InitStruct.DataWidth = LL_LPUART_DATAWIDTH_8B;
  LPUART_InitStruct.StopBits = LL_LPUART_STOPBITS_1;
  LPUART_InitStruct.Parity = LL_LPUART_PARITY_NONE;
  LPUART_InitStruct.TransferDirection = LL_LPUART_DIRECTION_TX_RX;
  LPUART_InitStruct.HardwareFlowControl = LL_LPUART_HWCONTROL_NONE;
  LL_LPUART_Init(LPUART1, &LPUART_InitStruct);
  /* USER CODE BEGIN LPUART1_Init 2 */

  /* USER CODE END LPUART1_Init 2 */
}

/**
 * @brief USART1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_USART1_UART_Init(void) {

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  LL_USART_InitTypeDef USART_InitStruct = {0};

  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART1);

  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);
  /**USART1 GPIO Configuration
  PA9   ------> USART1_TX
  PA10   ------> USART1_RX
  */
  GPIO_InitStruct.Pin = LL_GPIO_PIN_9;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_4;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_10;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_4;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  USART_InitStruct.BaudRate = 115200;
  USART_InitStruct.DataWidth = LL_USART_DATAWIDTH_8B;
  USART_InitStruct.StopBits = LL_USART_STOPBITS_1;
  USART_InitStruct.Parity = LL_USART_PARITY_NONE;
  USART_InitStruct.TransferDirection = LL_USART_DIRECTION_TX;
  USART_InitStruct.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
  USART_InitStruct.OverSampling = LL_USART_OVERSAMPLING_16;
  LL_USART_Init(USART1, &USART_InitStruct);
  LL_USART_ConfigAsyncMode(USART1);
  LL_USART_Enable(USART1);
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */
}

/**
 * @brief SPI1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_SPI1_Init(void) {

  /* USER CODE BEGIN SPI1_Init 0 */

  /* USER CODE END SPI1_Init 0 */

  LL_SPI_InitTypeDef SPI_InitStruct = {0};

  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SPI1);

  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);
  /**SPI1 GPIO Configuration
  PA5   ------> SPI1_SCK
  PA6   ------> SPI1_MISO
  PA7   ------> SPI1_MOSI
  */
  GPIO_InitStruct.Pin = LL_GPIO_PIN_5;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_6;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_7;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN SPI1_Init 1 */

  /* USER CODE END SPI1_Init 1 */
  /* SPI1 parameter configuration*/
  SPI_InitStruct.TransferDirection = LL_SPI_FULL_DUPLEX;
  SPI_InitStruct.Mode = LL_SPI_MODE_MASTER;
  SPI_InitStruct.DataWidth = LL_SPI_DATAWIDTH_8BIT;
  SPI_InitStruct.ClockPolarity = LL_SPI_POLARITY_HIGH;
  SPI_InitStruct.ClockPhase = LL_SPI_PHASE_2EDGE;
  SPI_InitStruct.NSS = LL_SPI_NSS_SOFT;
  SPI_InitStruct.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV64;
  SPI_InitStruct.BitOrder = LL_SPI_MSB_FIRST;
  SPI_InitStruct.CRCCalculation = LL_SPI_CRCCALCULATION_ENABLE;
  SPI_InitStruct.CRCPoly = 7;
  LL_SPI_Init(SPI1, &SPI_InitStruct);
  LL_SPI_SetStandard(SPI1, LL_SPI_PROTOCOL_MOTOROLA);
  /* USER CODE BEGIN SPI1_Init 2 */

  /* USER CODE END SPI1_Init 2 */
}

/**
 * @brief TIM2 Initialization Function
 * @param None
 * @retval None
 */
static void MX_TIM2_Init(void) {

  /* USER CODE BEGIN TIM2_Init 0 */
  /* USER CODE END TIM2_Init 0 */

  LL_TIM_InitTypeDef TIM_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM2);

  /* TIM2 interrupt Init */
  NVIC_SetPriority(TIM2_IRQn, 0);
  NVIC_EnableIRQ(TIM2_IRQn);

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  TIM_InitStruct.Prescaler = 119;
  TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
  TIM_InitStruct.Autoreload = 999;
  TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
  LL_TIM_Init(TIM2, &TIM_InitStruct);
  LL_TIM_DisableARRPreload(TIM2);
  LL_TIM_SetClockSource(TIM2, LL_TIM_CLOCKSOURCE_INTERNAL);
  LL_TIM_SetTriggerOutput(TIM2, LL_TIM_TRGO_RESET);
  LL_TIM_DisableMasterSlaveMode(TIM2);
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */
}

/**
 * @brief TIM6 Initialization Function
 * @param None
 * @retval None
 */
static void MX_TIM6_Init(void) {

  /* USER CODE BEGIN TIM6_Init 0 */

  /* USER CODE END TIM6_Init 0 */

  LL_TIM_InitTypeDef TIM_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM6);

  /* TIM6 interrupt Init */
  NVIC_SetPriority(TIM6_DAC_IRQn, 3);
  NVIC_EnableIRQ(TIM6_DAC_IRQn);

  /* USER CODE BEGIN TIM6_Init 1 */
  TIM_InitStruct.Autoreload = ((LED_PERIOD * 1000) / 5) - 1;
  /* USER CODE END TIM6_Init 1 */
  TIM_InitStruct.Prescaler = 60000;
  TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
  // TIM_InitStruct.Autoreload = 65535;
  LL_TIM_Init(TIM6, &TIM_InitStruct);
  LL_TIM_DisableARRPreload(TIM6);
  LL_TIM_SetTriggerOutput(TIM6, LL_TIM_TRGO_RESET);
  LL_TIM_DisableMasterSlaveMode(TIM6);
  /* USER CODE BEGIN TIM6_Init 2 */

  /* USER CODE END TIM6_Init 2 */
}

/**
 * @brief TIM22 Initialization Function
 * @param None
 * @retval None
 */
static void MX_TIM22_Init(void) {

  /* USER CODE BEGIN TIM22_Init 0 */
  /* USER CODE END TIM22_Init 0 */

  LL_TIM_InitTypeDef TIM_InitStruct = {0};

  /* Peripheral clock enable */
  LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM22);

  /* TIM22 interrupt Init */
  NVIC_SetPriority(TIM22_IRQn, 2);
  NVIC_EnableIRQ(TIM22_IRQn);

  /* USER CODE BEGIN TIM22_Init 1 */
  TIM_InitStruct.Autoreload = ((TIME_PERIOD * 1000) / 5) - 1;
  /* USER CODE END TIM22_Init 1 */
  TIM_InitStruct.Prescaler = 60000;
  TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
  // TIM_InitStruct.Autoreload = 2400;
  TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
  LL_TIM_Init(TIM22, &TIM_InitStruct);
  LL_TIM_DisableARRPreload(TIM22);
  LL_TIM_SetClockSource(TIM22, LL_TIM_CLOCKSOURCE_INTERNAL);
  LL_TIM_SetTriggerOutput(TIM22, LL_TIM_TRGO_RESET);
  LL_TIM_DisableMasterSlaveMode(TIM22);
  /* USER CODE BEGIN TIM22_Init 2 */

  /* USER CODE END TIM22_Init 2 */
}

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

  /* GPIO Ports Clock Enable */
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOC);
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOH);
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOB);

  /**/
  LL_GPIO_ResetOutputPin(LED_GPIO_Port, LED_Pin);

  /**/
  LL_GPIO_ResetOutputPin(LPS_CS_GPIO_Port, LPS_CS_Pin);

  /**/
  LL_GPIO_ResetOutputPin(RF_Boost_GPIO_Port, RF_Boost_Pin);

  /**/
  LL_GPIO_ResetOutputPin(ADF_TX_Data_GPIO_Port, ADF_TX_Data_Pin);

  /**/
  LL_GPIO_ResetOutputPin(GPS_ON_GPIO_Port, GPS_ON_Pin);

  /**/
  LL_GPIO_ResetOutputPin(RADIO_EN_GPIO_Port, RADIO_EN_Pin);

  /**/
  LL_GPIO_ResetOutputPin(ADF_CLK_GPIO_Port, ADF_CLK_Pin);

  /**/
  LL_GPIO_ResetOutputPin(ADF_Data_GPIO_Port, ADF_Data_Pin);

  /**/
  LL_GPIO_ResetOutputPin(ADF_LE_GPIO_Port, ADF_LE_Pin);

  /**/
  LL_GPIO_ResetOutputPin(POWER_ON_GPIO_Port, POWER_ON_Pin);

  /**/
  LL_GPIO_ResetOutputPin(ADF_CE_GPIO_Port, ADF_CE_Pin);

  /**/
  LL_GPIO_SetOutputPin(NTC_475K_GPIO_Port, NTC_475K_Pin);

  /**/
  LL_GPIO_ResetOutputPin(NTC_36K_GPIO_Port, NTC_36K_Pin);

  /**/
  LL_GPIO_SetOutputPin(NTC_12K_GPIO_Port, NTC_12K_Pin);

  /**/
  LL_GPIO_SetOutputPin(NTC_2M_GPIO_Port, NTC_2M_Pin);

  /**/
  LL_GPIO_SetOutputPin(NTC_330K_GPIO_Port, NTC_330K_Pin);

  /**/
  GPIO_InitStruct.Pin = BUTTON_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(BUTTON_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = LED_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(LED_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = LPS_CS_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(LPS_CS_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = RF_Boost_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(RF_Boost_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = ADF_TX_Data_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(ADF_TX_Data_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = GPS_ON_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(GPS_ON_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = RADIO_EN_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(RADIO_EN_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = ADF_CLK_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(ADF_CLK_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = ADF_Data_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(ADF_Data_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = ADF_LE_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(ADF_LE_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = LL_GPIO_PIN_8;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = POWER_ON_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(POWER_ON_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = ADF_CE_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(ADF_CE_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = NTC_475K_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(NTC_475K_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = NTC_36K_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(NTC_36K_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = NTC_12K_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(NTC_12K_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = NTC_2M_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(NTC_2M_GPIO_Port, &GPIO_InitStruct);

  /**/
  GPIO_InitStruct.Pin = NTC_330K_Pin;
  GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT;
  GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(NTC_330K_GPIO_Port, &GPIO_InitStruct);

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

/* USER CODE BEGIN 4 */
void GPS_Handler(void) {
  if (LL_LPUART_IsEnabledIT_RXNE(LPUART1) &&
      LL_LPUART_IsActiveFlag_RXNE(LPUART1)) {
    if (GpsBufferCounter >= GpsRxBuffer_SIZE) {
      GpsBufferCounter = 0;
      GpsBufferReady = true;
    }
    GpsRxBuffer[GpsBufferCounter] = LL_LPUART_ReceiveData8(LPUART1);
    GpsBufferCounter++;
  } else if (LL_LPUART_IsActiveFlag_ORE(LPUART1)) {
    LL_LPUART_ClearFlag_ORE(LPUART1);
#ifdef DEBUG
    printf("ORE!\r\n");
#endif
  }
}
void LED_Handler(void) {
#if LED_MODE == 2
#if GPS_TYPE == 1
  uint8_t fix = NmeaData.Fix;
  if (LED_DISABLE_ALT != 0) {
    if (NmeaData.Alt >= LED_DISABLE_ALT) {
      LL_TIM_DisableCounter(TIM6);
      LL_TIM_DisableIT_UPDATE(TIM6);
    }
  }
#elif GPS_TYPE == 2
  uint8_t fix = GpsData.Fix;
  if (LED_DISABLE_ALT != 0) {
    if (GpsData.Alt >= LED_DISABLE_ALT) {
      LL_TIM_DisableCounter(TIM6);
      LL_TIM_DisableIT_UPDATE(TIM6);
    }
  }
#endif
  for (; fix > 0; fix--) {
    LL_GPIO_SetOutputPin(LED_GPIO_Port, LED_Pin);
    LL_mDelay(50);
    LL_GPIO_ResetOutputPin(LED_GPIO_Port, LED_Pin);
    LL_mDelay(100);
  }
#endif
}
void DelayWithIWDG(uint16_t time) {
  for (uint8_t i = 0; i < time / 100; i++) {
    LL_IWDG_ReloadCounter(IWDG);
    LL_mDelay(100);
  }
}
#if GPS_TYPE == 1
void GpsAirborne(void) {
  for (uint8_t ih = 0; ih < 2; ih++) {
    for (uint8_t ig = 0; ig < 44; ig++) {
      while (!LL_LPUART_IsActiveFlag_TXE(LPUART1)) {
      }
      LL_LPUART_TransmitData8(LPUART1, GPS_airborne[ig]);
    }
    while (!LL_LPUART_IsActiveFlag_TC(LPUART1)) {
    }
    if (ih == 0)
      DelayWithIWDG(900);
  }
}
#endif
/* 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 */