Subversion Repositories ScreenTimer

/* USER CODE BEGIN Header */

/**

 ******************************************************************************

 * @file           : main.c

 * @brief          : Main program body

 ******************************************************************************

 * @attention

 *

 * Copyright (c) 2022 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"

/* Private includes ----------------------------------------------------------*/

/* USER CODE BEGIN Includes */

#include "stm32f0xx_hal_adc_ex.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/

/* USER CODE BEGIN PTD */

// turn on the watchdog timer

#define WATCHDOG

/// \brief Enumeration of heater states

typedef enum

{

  HEAT_OFF,        // heater is off

  HEAT_PENDING,    // heater request is pending

  HEAT_ON,         // heater is switched on

  HEAT_ON_LOW_VOLT // heater timer running, voltage is low

} heaterControl;

/// \brief state for heater channel

#pragma pack(push, 1)

typedef struct

{

  heaterControl control; ///< control state

  uint16_t LEDintensity; ///< current LED intensity

  uint16_t LEDtarget;    ///< current LED target intensity

  uint32_t heatTimer;    /// < tick time counter for heater channel

  uint8_t buttonCount;   /// < debounce counter

  uint8_t tick;          /// < a value that increments 

  uint16_t checkSum;     /// < checksum used in post-reset validation

} heaterStatus;

#pragma pack(pop)

/// \brief enumeration of LED intensities for each case

typedef enum

{

  INTENSITY_OFF = 1,          // dim glow

  INTENSITY_STBY_DIM = 8,     // flashing waiting for batttery voltage - dim

  INTENSITY_STBY_BRIGHT = 32, // flashing waiting for battery voltage -bright

  INTENSITY_ON_LOW = 64,      // night time intensity - dash lighting on

  INTENSITY_ON = 256          // daytime intensity  - dash lighting off

} ledIntensities;

/// \brief Enumeration of active ADC channels

typedef enum

{

  IGNITION_VOLT_CHAN = 0,

  DASHBOARD_VOLT_CHAN,

  TEMPERATURE_CHAN,

  VREF_CHAN

} adcChannels;

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/

/* USER CODE BEGIN PD */

/// \brief LED intensities :

/// multiply by INTENSITY_STEP / (INTENSITY_STEP-1) to fade up  intensity

/// multiply by (INTENSITY_STEP-1) / INTENSITY_STEP to fade down intensity

#define INTENSITY_STEP 12

/// \brief ADC filtering parameters

#define ADC_TMPGRP_BUF_DEPTH 4

#define ADC_TEMPGRP_NUM_CHANNELS 4

/// \brief ADC scaling for power supply measurement

///  Resistor ladder is 47k top 10k bottom :ratio expressed as 1000 times value

#define IGN_ADC_SCALE 5556 // should be 5700 , but resistor ratio is 5.749 not

// Battery voltage * 1000

// alternator charging

#define HEATER_ON_VOLTAGE 13500

// battery OK under load

#define HEATER_OFF_VOLTAGE 11500

// if the dashboard/backlight power is over 5 volts, consider dimming LEDS

#define DASH_ON_VOLTAGE 5000

// temperature which is regarded as cold

#define COLD_TEMPERATURE 3

// Default timer run time in milli seconds

#define WARM_TIMER_RUN_TICKS 400000L

#define COLD_TIMER_RUN_TICKS 600000L

/*

 * Register addresses were taken from DM00088500 (STM32F030 datasheet)

 * For non-STM32F030 microcontrollers register addresses

 * might need to be modified according to the respective datasheet.

 */

// Temperature sensor raw value at 30 degrees C, VDDA=3.3V

#define TEMP30_CAL_ADDR ((uint16_t *)((uint32_t)0x1FFFF7B8))

// Internal voltage reference raw value at 30 degrees C, VDDA=3.3V

#define VREFINT_CAL_ADDR ((uint16_t *)((uint32_t)0x1FFFF7BA))

// internal temperature sensor : 1000 times ADC slope per degree C

#define AVG_SLOPE (5336L)

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/

/* USER CODE BEGIN PM */

/* USER CODE END PM */

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

ADC_HandleTypeDef hadc;

DMA_HandleTypeDef hdma_adc;

TIM_HandleTypeDef htim3;

TIM_HandleTypeDef htim14;

WWDG_HandleTypeDef hwwdg;

/* USER CODE BEGIN PV */

// storage for heater status

heaterStatus const ResetHeater = {HEAT_OFF, 0, 0, 0, 0, 0};

heaterStatus HeaterLeft = ResetHeater;

heaterStatus HeaterRight = ResetHeater;

#define BACKUP_COPIES 2

heaterStatus __attribute__((section(".persistent"))) BackupLeft[BACKUP_COPIES];

heaterStatus __attribute__((section(".persistent"))) BackupRight[BACKUP_COPIES];

// storage for ADC DMA'd samples

uint16_t ADC_Samples[ADC_TMPGRP_BUF_DEPTH * ADC_TEMPGRP_NUM_CHANNELS];

// see https://techoverflow.net/2015/01/13/reading-stm32f0-internal-temperature-and-voltage-using-chibios/

typedef struct

{

  int32_t temperature;

  int32_t vdda;

  int32_t batteryVoltage;

  int32_t dashVoltage;

} analogReadings;

analogReadings vals = {0, 0, 0, 0};

/* 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_ADC_Init(void);

static void MX_TIM3_Init(void);

static void MX_TIM14_Init(void);

static void MX_WWDG_Init(void);

/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/

/* USER CODE BEGIN 0 */

void setLEDLeft(uint16_t brightness)

{

  __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_4, brightness);

}

void setLEDRight(uint16_t brightness)

{

  __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_2, brightness);

}

void setLEDEval(uint16_t brightness)

{

  __HAL_TIM_SET_COMPARE(&htim14, TIM_CHANNEL_1, brightness);

}

void setRelayLeft(heaterControl control)

{

  HAL_GPIO_WritePin(RelayLeft_GPIO_Port, RelayLeft_Pin, control == HEAT_ON ? GPIO_PIN_SET : GPIO_PIN_RESET);

}

void setRelayRight(heaterControl control)

{

  HAL_GPIO_WritePin(RelayRight_GPIO_Port, RelayRight_Pin, control == HEAT_ON ? GPIO_PIN_SET : GPIO_PIN_RESET);

}

// return 1 when button pressed (using NC button)

uint8_t getButtonLeft()

{

  return HAL_GPIO_ReadPin(PushLeft_GPIO_Port, PushLeft_Pin) == GPIO_PIN_SET;

}

// return 1 when button pressed (using NC button)

uint8_t getButtonRight()

{

  return HAL_GPIO_ReadPin(PushRight_GPIO_Port, PushRight_Pin) == GPIO_PIN_SET;

}

void readTemperatureVDDA(void)

{

  // NOTE: Computation is performed in 32 bits, but result is converted to 16 bits later.s

  /**

   * Compute average of temperature sensor raw output

   * and vrefint raw output

   */

  int32_t tempAvg = 0;

  int32_t vrefintAvg = 0;

  int32_t batteryAvg = 0;

  int32_t dashAvg = 0;

  // Samples are alternating: ignition, temp, vrefint, ignition, temp, vrefint, ...

  for (int i = 0; i < (ADC_TMPGRP_BUF_DEPTH * ADC_TEMPGRP_NUM_CHANNELS); i += ADC_TEMPGRP_NUM_CHANNELS)

  {

    batteryAvg += ADC_Samples[i + IGNITION_VOLT_CHAN];

    tempAvg += ADC_Samples[i + TEMPERATURE_CHAN];

    vrefintAvg += ADC_Samples[i + VREF_CHAN];

    dashAvg += ADC_Samples[i + DASHBOARD_VOLT_CHAN];

  }

  tempAvg /= ADC_TMPGRP_BUF_DEPTH;

  vrefintAvg /= ADC_TMPGRP_BUF_DEPTH;

  batteryAvg /= ADC_TMPGRP_BUF_DEPTH;

  dashAvg /= ADC_TMPGRP_BUF_DEPTH;

  /**

   * Compute temperature in celsius

   *

   * Note that we need to normalize the value first by applying

   * the (actual VDDA / VDDARef) ratio.

   *

   * Note: VDDA_Actual = 3.3V * VREFINT_CAL / vrefintAvg

   * Therefore, the ratio mentioned above is equal to

   * q = VREFINT_CAL / vrefintAvg

   */

  int32_t temperature = ((int32_t)*TEMP30_CAL_ADDR - tempAvg) * 1000;

  temperature = temperature / AVG_SLOPE;

  temperature = temperature + 30L;

  vals.temperature = temperature;

  vals.vdda = (3300 * (*VREFINT_CAL_ADDR)) / vrefintAvg;

  vals.batteryVoltage = (IGN_ADC_SCALE * batteryAvg) / 4096 * vals.vdda / 1000; //* 3300 * (*VREFINT_CAL_ADDR)) / batteryAvg);

  vals.dashVoltage = (IGN_ADC_SCALE * dashAvg) / 4096 * vals.vdda / 1000;

}

uint16_t getBatteryVoltage()

{

  return vals.batteryVoltage;

}

int8_t getTemperature()

{

  return vals.temperature;

}

uint16_t getDashVoltage()

{

  return vals.dashVoltage;

}

uint16_t checkSum(heaterStatus *status)

{

  uint16_t sum = 0xFFFF;

  uint8_t *ptr = (uint8_t *)(status);

  for (uint8_t *p = ptr; p < ptr + sizeof(heaterStatus) - sizeof(uint16_t); p++)

  {

    sum *= 41;

    sum += *p;

  }

  return sum;

}

/// @brief  Periodic status save into RAM.

/// @param status status to save

/// @param saveStatus address of array to save status in

/// @param iter  iteration of saving

/// @return new iteratiom

uint8_t saveStatus(heaterStatus *status, heaterStatus *saveStatus, uint8_t iter)

{

  status->checkSum = checkSum(status);

  if (iter >= BACKUP_COPIES)

    iter = 0;

  saveStatus[iter] = *status;

  iter++;

  return iter;

}

/// @brief Recover status from RAM after reset/crash

/// @param saveStatus pointer to array of saved status

/// @return pointer to valid saved or reset status

heaterStatus const *recoverStatus(heaterStatus *saveStatus)

{

  for (int i = 0; i < BACKUP_COPIES; i++)

  {

    if (saveStatus[i].checkSum == checkSum(saveStatus + i))

      return saveStatus + i;

  };

  // default return a reset state

  return &ResetHeater;

}

void process(heaterStatus *status, uint8_t button,  int8_t temperature, uint16_t battery, uint16_t dashboard)

{

  // deal with button debounce

    uint8_t buttonPressed = 0;

    uint8_t longButtonPressed = 0;

    // deal with intensity

    uint16_t intensity;

    status->tick++;

    if ((status->tick % 128) < 64)

    {

      intensity = INTENSITY_STBY_DIM;

    }

    else{

      intensity = INTENSITY_STBY_BRIGHT;

    }

  if (status->buttonCount >=100)

    status->buttonCount=100;

  if (button && status->buttonCount < 100)

  {

    status->buttonCount++;

    if (status->buttonCount == 10)

      buttonPressed = 1;

    if (status->buttonCount == 100)

      longButtonPressed = 1;

  }

  if (!button)

    status->buttonCount = 0;

  // deal with LED brightness control

  if (status->LEDintensity < status->LEDtarget)

  {

    // do an exponential fade up

    uint16_t tmp = status->LEDintensity;

    tmp *= INTENSITY_STEP;

    tmp /= INTENSITY_STEP - 1;

    // if nothing happened increment

    status->LEDintensity = tmp == status->LEDintensity ? tmp + 1 : tmp;

    // handle overshoot

    if (status->LEDintensity > status->LEDtarget)

      status->LEDintensity = status->LEDtarget;

  }

  if (status->LEDintensity > status->LEDtarget)

  {

    // do an exponential fade down

    uint16_t tmp = status->LEDintensity;

    tmp *= INTENSITY_STEP - 1;

    tmp /= INTENSITY_STEP;

    // if nothing happened, decrement

    status->LEDintensity = tmp == status->LEDintensity ? tmp - 1 : tmp;

    // handle undershoot

    if (status->LEDintensity < status->LEDtarget)

      status->LEDintensity = status->LEDtarget;

  }

  // deal with state machine

  switch (status->control)

  {

  case HEAT_OFF: // heater is off

    status->LEDtarget = INTENSITY_OFF;

    if (buttonPressed)

      status->control = HEAT_PENDING;

    break;

  case HEAT_PENDING: // heater request is pending

    status->LEDtarget = intensity;

    if (buttonPressed)

    {

      status->control = HEAT_OFF;

      break;

    }

    if (battery > HEATER_ON_VOLTAGE)

    {

      // start the timer

      status->heatTimer = HAL_GetTick();

      status->control = HEAT_ON;

      break;

    }

    break;

  case HEAT_ON: // heater is switched on

  case HEAT_ON_LOW_VOLT:

    // specific conditions

    if (status->control == HEAT_ON)

    {

      if (battery < HEATER_OFF_VOLTAGE)

        status->control = HEAT_ON_LOW_VOLT;

      status->LEDtarget = (dashboard > DASH_ON_VOLTAGE) ? INTENSITY_ON : INTENSITY_ON_LOW;

    }

    if (status->control == HEAT_ON_LOW_VOLT)

    {

      if (battery > HEATER_ON_VOLTAGE)

        status->control = HEAT_ON;

      status->LEDtarget = intensity;

    }

    // common code

    // press and hold to turn off

    if (longButtonPressed)

    {

      status->control = HEAT_OFF;

      break;

    }

    // press button to extend time

    if (buttonPressed)

    {

      // restart the timer

      status->heatTimer = HAL_GetTick();

      break;

    }

    //  respond to temperature input

    uint32_t timeLimit = (temperature < COLD_TEMPERATURE) ? COLD_TIMER_RUN_TICKS : WARM_TIMER_RUN_TICKS;

    if ((HAL_GetTick() - status->heatTimer) > timeLimit)

    {

      status->control = HEAT_OFF;

      break;

    }

    break;

    // check timer value here

  }

}

/* USER CODE END 0 */

/**

 * @brief  The application entry point.

 * @retval int

 */

int main(void)

{

  /* USER CODE BEGIN 1 */

  uint8_t saveChannel = 0;

  HeaterLeft = *recoverStatus(BackupLeft);

  HeaterRight = *recoverStatus(BackupRight);

  /* 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_ADC_Init();

  MX_TIM3_Init();

  MX_TIM14_Init();

#if defined WATCHDOG

  MX_WWDG_Init();

#endif

  /* USER CODE BEGIN 2 */

  HAL_ADC_MspInit(&hadc);

  HAL_ADC_Start_DMA(&hadc, (uint32_t *)ADC_Samples, ADC_TMPGRP_BUF_DEPTH * ADC_TEMPGRP_NUM_CHANNELS);

  HAL_ADC_Start(&hadc);

  // turn on temperature sensor and VREF

  ADC->CCR |= ADC_CCR_TSEN | ADC_CCR_VREFEN;

  // initialise all the STMCubeMX stuff

  HAL_TIM_Base_MspInit(&htim3);

  HAL_TIM_Base_MspInit(&htim14);

  // Start the counter

  HAL_TIM_Base_Start(&htim3);

  HAL_TIM_Base_Start(&htim14);

  HAL_TIM_OC_Start(&htim3, TIM_CHANNEL_2);

  HAL_TIM_OC_Start(&htim3, TIM_CHANNEL_4);

  HAL_TIM_OC_Start(&htim14, TIM_CHANNEL_1);

  HeaterLeft.LEDtarget = INTENSITY_OFF;

  HeaterRight.LEDtarget = INTENSITY_OFF;

  /* USER CODE END 2 */

  /* Infinite loop */

  /* USER CODE BEGIN WHILE */

  while (1)

  {

    readTemperatureVDDA();

    int8_t temperature = getTemperature();

    uint16_t batteryVoltage = getBatteryVoltage();

    uint16_t dashVoltage = getDashVoltage();

    setLEDLeft(HeaterLeft.LEDintensity);

    setLEDRight(HeaterRight.LEDintensity);

    setLEDEval(HeaterLeft.LEDintensity);

    setRelayLeft(HeaterLeft.control);

    setRelayRight(HeaterRight.control);

    // generate different intensity targets for LED pulsation effect

    process(&HeaterLeft, getButtonLeft(),  temperature, batteryVoltage, dashVoltage);

    process(&HeaterRight, getButtonRight(),  temperature, batteryVoltage, dashVoltage);

    /* note the WWDG configuration also needs to be updated if this delay is changed */

    HAL_Delay(10);

#if defined WATCHDOG

    HAL_WWDG_Refresh(&hwwdg);

#endif

    saveStatus(&HeaterLeft, BackupLeft, saveChannel);

    saveChannel = saveStatus(&HeaterRight, BackupRight, saveChannel);

    /* 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};

  /** Initializes the RCC Oscillators according to the specified parameters

   * in the RCC_OscInitTypeDef structure.

   */

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;

  RCC_OscInitStruct.HSEState = RCC_HSE_ON;

  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

  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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;

  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)

  {

    Error_Handler();

  }

}

/**

 * @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 */

  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC_Init 1 */

  /* USER CODE END ADC_Init 1 */

  /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)

   */

  hadc.Instance = ADC1;

  hadc.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2;

  hadc.Init.Resolution = ADC_RESOLUTION_12B;

  hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;

  hadc.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;

  hadc.Init.EOCSelection = ADC_EOC_SEQ_CONV;

  hadc.Init.LowPowerAutoWait = DISABLE;

  hadc.Init.LowPowerAutoPowerOff = DISABLE;

  hadc.Init.ContinuousConvMode = DISABLE;

  hadc.Init.DiscontinuousConvMode = DISABLE;

  hadc.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T3_TRGO;

  hadc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;

  hadc.Init.DMAContinuousRequests = ENABLE;

  hadc.Init.Overrun = ADC_OVR_DATA_PRESERVED;

  if (HAL_ADC_Init(&hadc) != HAL_OK)

  {

    Error_Handler();

  }

  /** Configure for the selected ADC regular channel to be converted.

   */

  sConfig.Channel = ADC_CHANNEL_0;

  sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;

  sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;

  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)

  {

    Error_Handler();

  }

  /** Configure for the selected ADC regular channel to be converted.

   */

  sConfig.Channel = ADC_CHANNEL_1;

  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)

  {

    Error_Handler();

  }

  /** Configure for the selected ADC regular channel to be converted.

   */

  sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;

  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)

  {

    Error_Handler();

  }

  /** Configure for the selected ADC regular channel to be converted.

   */

  sConfig.Channel = ADC_CHANNEL_VREFINT;

  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)

  {

    Error_Handler();

  }

  /* USER CODE BEGIN ADC_Init 2 */

  /* USER CODE END ADC_Init 2 */

}

/**

 * @brief TIM3 Initialization Function

 * @param None

 * @retval None

 */

static void MX_TIM3_Init(void)

{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  TIM_OC_InitTypeDef sConfigOC = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */

  htim3.Instance = TIM3;

  htim3.Init.Prescaler = 79;

  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;

  htim3.Init.Period = 255;

  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)

  {

    Error_Handler();

  }

  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)

  {

    Error_Handler();

  }

  if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)

  {

    Error_Handler();

  }

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;

  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)

  {

    Error_Handler();

  }

  sConfigOC.OCMode = TIM_OCMODE_PWM1;

  sConfigOC.Pulse = 1;

  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)

  {

    Error_Handler();

  }

  sConfigOC.Pulse = 64;

  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)

  {

    Error_Handler();

  }

  /* USER CODE BEGIN TIM3_Init 2 */

  /* USER CODE END TIM3_Init 2 */

  HAL_TIM_MspPostInit(&htim3);

}

/**

 * @brief TIM14 Initialization Function

 * @param None

 * @retval None

 */

static void MX_TIM14_Init(void)

{

  /* USER CODE BEGIN TIM14_Init 0 */

  /* USER CODE END TIM14_Init 0 */

  TIM_OC_InitTypeDef sConfigOC = {0};

  /* USER CODE BEGIN TIM14_Init 1 */

  /* USER CODE END TIM14_Init 1 */

  htim14.Instance = TIM14;

  htim14.Init.Prescaler = 79;

  htim14.Init.CounterMode = TIM_COUNTERMODE_UP;

  htim14.Init.Period = 255;

  htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

  htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

  if (HAL_TIM_Base_Init(&htim14) != HAL_OK)

  {

    Error_Handler();

  }

  if (HAL_TIM_PWM_Init(&htim14) != HAL_OK)

  {

    Error_Handler();

  }

  sConfigOC.OCMode = TIM_OCMODE_PWM2;

  sConfigOC.Pulse = 128;

  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

  if (HAL_TIM_PWM_ConfigChannel(&htim14, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)

  {

    Error_Handler();

  }

  /* USER CODE BEGIN TIM14_Init 2 */

  /* USER CODE END TIM14_Init 2 */

  HAL_TIM_MspPostInit(&htim14);

}

/**

 * @brief WWDG Initialization Function

 * @param None

 * @retval None

 */

static void MX_WWDG_Init(void)

{

  /* USER CODE BEGIN WWDG_Init 0 */

  /* USER CODE END WWDG_Init 0 */

  /* USER CODE BEGIN WWDG_Init 1 */

  /* USER CODE END WWDG_Init 1 */

  hwwdg.Instance = WWDG;

  hwwdg.Init.Prescaler = WWDG_PRESCALER_1;

  hwwdg.Init.Window = 83;

  hwwdg.Init.Counter = 93;

  hwwdg.Init.EWIMode = WWDG_EWI_DISABLE;

  if (HAL_WWDG_Init(&hwwdg) != HAL_OK)

  {

    Error_Handler();

  }

  /* USER CODE BEGIN WWDG_Init 2 */

  /* USER CODE END WWDG_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_Channel1_IRQn interrupt configuration */

  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);

  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);

}

/**

 * @brief GPIO Initialization Function

 * @param None

 * @retval None

 */

static void MX_GPIO_Init(void)

{

  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */

  __HAL_RCC_GPIOF_CLK_ENABLE();

  __HAL_RCC_GPIOA_CLK_ENABLE();

  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */

  HAL_GPIO_WritePin(GPIOA, RelayRight_Pin | RelayLeft_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pins : PA2 PA3 PushLeft_Pin */

  GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3 | PushLeft_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

  GPIO_InitStruct.Pull = GPIO_PULLUP;

  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : RelayRight_Pin RelayLeft_Pin */

  GPIO_InitStruct.Pin = RelayRight_Pin | RelayLeft_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : PushRight_Pin */

  GPIO_InitStruct.Pin = PushRight_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  HAL_GPIO_Init(PushRight_GPIO_Port, &GPIO_InitStruct);

}