ThomasBandin / WvfrmGen_ELEN0448 - Files

11-07-19-01-finnnnn-de-journee.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"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "math.h"
#include "string.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 hspi1;
SPI_HandleTypeDef hspi2;

TIM_HandleTypeDef htim17;

UART_HandleTypeDef huart2;

/* USER CODE BEGIN PV */

uint8_t default_bits[16] = {0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t bits[8];

uint16_t table_msg[20] = {12288, 16368, 12288, 16368, 12288, 16368, 12288, 16368, 12288, 16368,
	    12288, 16368, 12288, 16368, 12288, 16368, 12288, 16368, 12288, 16368};
uint16_t square_msg[2];	// middle is 14336

uint8_t default_bits_r[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t bits_r[8];
uint8_t var_r[3];

uint8_t signal_form; // Wave form selection
uint8_t n;		// Nbr de pts dans une période A DEFINIR SELON LA FREQ
uint8_t i;		// Le point numéro i

volatile uint8_t flag_change_signal;
volatile uint8_t flag_freq_increase;
volatile uint8_t flag_freq_decrease;
volatile uint8_t flag_tim17_overflow;
volatile uint8_t flag_regenerate_table;

uint8_t nb_prescalers;
uint16_t prescalers[3];	// Max : 65535, define values further
uint8_t prescaler_idx;

char uart_buffer[50];
uint8_t my_word[13] = "hello world";

#define PI 3.141592653589793


/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI1_Init(void);
static void MX_TIM17_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_SPI2_Init(void);
/* USER CODE BEGIN PFP */
void table_generation (uint8_t prescaler_idx, uint8_t signal_form);
void Signal_square(uint16_t *square_msg, uint8_t n);
uint16_t Signal_triangle(uint8_t *default_bits, uint8_t *bits, uint8_t n, uint8_t i);
uint16_t Signal_sine(uint8_t *default_bits, uint8_t *bits, uint8_t n, uint8_t i);
void dec_to_bin(uint8_t value, uint8_t *bits);
void copy_in_vector(uint8_t *bits, uint8_t *default_bits);
void copy_in_vector_r(uint8_t *bits, uint8_t *default_bits);
uint16_t bin_to_dec(uint8_t *bits);

/* USER CODE END PFP */

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

/* 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_SPI1_Init();
  MX_TIM17_Init();
  MX_USART2_UART_Init();
  MX_SPI2_Init();
  /* USER CODE BEGIN 2 */

  flag_change_signal = 0;
  flag_freq_increase = 0;
  flag_freq_decrease = 0;
  flag_tim17_overflow = 0;
  flag_regenerate_table = 0;
  prescaler_idx = 0;

  nb_prescalers = 3;
  prescalers[0] = 1;
  prescalers[1] = 2;
  prescalers[2] = 65535;

  signal_form = 0;
  n = 2;		// Nbr de pts dans une période A DEFINIR SELON LA FREQ
  i = 0;		// Le point numéro i


  square_msg[0] = 12288;	// 0
  square_msg[1] = 16368;	// 255

  var_r[0] = 6;
  var_r[1] = 127/2;
  var_r[2] = 127;

  HAL_TIM_Base_Start_IT(&htim17);

  SPI1->CR1 |= 0x904 ; /* 100 1000 0100 ou 0x904 */
  /* RXONLY = 1 ;SSM=0 ;SSI = 0 ;LSBFIRST=1; SPE=0 ;BR=000 ;MSTR = 1 ;CPOL = 0 ;CPHA = 0 */
  SPI1->CR2 = 3852 ;
  /* après config ioc (NSS Hardware) (voir spi sans interruptions) SPI1 ->CR2 = 0b 1111 0000 1100 */
  /*la ligne «SPI1->CR2 = 3852 ;n’est pas nécessaire si on a configure correctement le port SPI dans config.IOC.
  la ligne «SPI1->CR1 |= 0x904;n’est pas nécessaire si on a configure correctement le port SPI dans config.IOC.
  Voir debugger */
  /* DS= 1111; TXEIE = 0; RXNEIE = 0 ;ERRIE=0 ; FRF = 0; NSSP=1 ;SSOE = 1 ;TXDMAEN = 0; RXDMAEN = 0 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */

	while (1)
	{
		if (flag_tim17_overflow)
		{
			flag_tim17_overflow = 0;

			if(flag_change_signal)
			{
				flag_change_signal = 0;
				flag_regenerate_table = 1;

				signal_form ++;

				if(signal_form > 2)
				{
				  signal_form = 0;
				}
			}

			if(flag_freq_decrease)
			{
				flag_freq_decrease = 0;
				flag_regenerate_table = 1;

				prescaler_idx += 1;
				if (prescaler_idx >= nb_prescalers)
				{
					prescaler_idx = nb_prescalers - 1;
				}
				htim17.Init.Prescaler = prescalers[prescaler_idx];
				HAL_TIM_Base_Init(&htim17);
				HAL_TIM_Base_Start_IT(&htim17);
			}

			if(flag_freq_increase)
			{
				flag_freq_increase = 0;
				flag_regenerate_table = 1;

				if (prescaler_idx > 0)
				{
					prescaler_idx -= 1;
				}

//				prescaler_idx -= 1;
//				if (prescaler_idx < 0)
//				{
//					prescaler_idx = 0;
//				}

				htim17.Init.Prescaler = prescalers[prescaler_idx];
				HAL_TIM_Base_Init(&htim17);
				HAL_TIM_Base_Start_IT(&htim17);
			}

			if (flag_regenerate_table)
			{
				flag_regenerate_table = 0;
				table_generation(prescaler_idx, signal_form);
			}

			// SEND BITS TO DAC FOR SIGNAL

			while (!(SPI1->SR & 2)) {}
			SPI1->CR1 |= 0x0040;	// Activate SPI

			SPI1->DR = table_msg[i];

			while (SPI1->SR & 0x80) {}
			SPI1->CR1 &= ~0x0040;	// Deactivate SPI

			// SEND BITS TO MCP (VARIABLE RESISTANCE)

//			dec_to_bin(var_r[0], bits_r);
//			copy_in_vector_r(bits_r, default_bits_r);

//			uint16_t twochar = 0b00000000 | var_r[0];

			uint8_t cmd = 0x00; // Write wiper 0
			uint8_t val = 127;  // entier

			uint16_t data = (cmd << 8) | val;

			while (!(SPI2->SR & 2)) {}
			HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9);
			SPI2->CR1 |= 0x0040;

			SPI2->DR = data;
//			SPI2->DR = twochar;
//			SPI2->DR = bin_to_dec(default_bits);

			while (SPI2->SR & 0x80) {}
			HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9);
			SPI2->CR1 &= ~0x0040;

//			// BEGIN SHOW IN UART WHAT'S SENT TO THE DAC
//			char buffer[32];
//			int length = sprintf(buffer, "table_msg[%d] = %u\r\n", i, table_msg[i]);
//			HAL_UART_Transmit(&huart2, (uint8_t*)buffer, length, 100);
//			HAL_Delay(50);
//			// END SHOW IN UART WHAT'S SENT TO THE DAC

			i++;

			if (i >= n)
			{
				i = 0;
			}

		}
	}

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

  /** Configure the main internal regulator output voltage
  */
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** 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.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 = 8;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

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

  /* USER CODE BEGIN SPI1_Init 1 */

  /* USER CODE END SPI1_Init 1 */
  /* SPI1 parameter configuration*/
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_16BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
  hspi1.Init.NSS = SPI_NSS_HARD_OUTPUT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 7;
  hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi1.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI1_Init 2 */

  /* USER CODE END SPI1_Init 2 */

}

/**
  * @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_16BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_HARD_OUTPUT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  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_ENABLE;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI2_Init 2 */

  /* USER CODE END SPI2_Init 2 */

}

/**
  * @brief TIM17 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM17_Init(void)
{

  /* USER CODE BEGIN TIM17_Init 0 */

  /* USER CODE END TIM17_Init 0 */

  /* USER CODE BEGIN TIM17_Init 1 */

  /* USER CODE END TIM17_Init 1 */
  htim17.Instance = TIM17;
  htim17.Init.Prescaler = 32000;
  htim17.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim17.Init.Period = 500;
  htim17.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim17.Init.RepetitionCounter = 0;
  htim17.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim17) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM17_Init 2 */

  /* USER CODE END TIM17_Init 2 */

}

/**
  * @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 = 9600;
  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.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  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 */

}

/**
  * @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_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, GPIO_PIN_RESET);

  /*Configure GPIO pins : PA5 PA6 PA7 */
  GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
  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 : PB2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : PA8 PA9 PA10 */
  GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);

  /* USER CODE BEGIN MX_GPIO_Init_2 */

  /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

void table_generation (uint8_t prescaler_idx, uint8_t signal_form)
{
	switch (prescaler_idx)
	{
	case 0:
		n = 20;
		break;
	case 1:
		n = 20;
		break;
	case 2:
		n = 40;
		break;
	}

	sprintf(uart_buffer, "===== IDX %d\r\n", prescaler_idx);
	HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);
	sprintf(uart_buffer, "===== PRESCALER %d\r\n", prescalers[prescaler_idx]);
	HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);

	switch (signal_form)
	{
	case 0:
		sprintf(uart_buffer, "===== SQUARE\r\n");
		HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);
		break;
	case 1:
		sprintf(uart_buffer, "===== TRIANGLE\r\n");
		HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);
		break;
	case 2:
		sprintf(uart_buffer, "===== SIN\r\n");
		HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);
		break;
	}

	for (uint8_t j = 0; j < n; j++)
	{
		switch (signal_form)
		{
		case 0:
			n = 2;
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_RESET);
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_RESET);
			table_msg[j] = square_msg[j % 2];
			break;

		case 1:
			if(n%2)		// If impair
			{
				n += 1;
			}
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_SET);
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_RESET);
			table_msg[j] = Signal_triangle(default_bits, bits, n, j);
			break;

		case 2:
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_RESET);
			HAL_GPIO_WritePin(GPIOA, GPIO_PIN_7, GPIO_PIN_SET);
			table_msg[j] = Signal_sine(default_bits, bits, n, j);
			break;
		}
	}

//	// TO PRINT VALUES OF INSTRUCTIONS FOR DAC
//	char buffer[32];
//	for (int j = 0; j < n; j++)
//	{
//	    // Convert to decimal string with newline
//	    int length = sprintf(buffer, "table_msg[%d] = %u\r\n", j, table_msg[j]);
//	    // Transmit string over UART
//	    HAL_UART_Transmit(&huart2, (uint8_t*)buffer, length, 100);
//	    HAL_Delay(50);
//	}
}

//void Signal_square(uint16_t *square_msg, uint8_t n)
//{
//    static uint8_t i = 0;
//
//    while (!(SPI1->SR & 2)) {}
//
//    SPI1->CR1 |= 0x0040;
//
//    SPI1->DR = square_msg[i];
//
//    i = (i + 1) % n;
//
//    while (SPI1->SR & 0x80) {}
//
//    // Désactive SPI (SPE = 0) -> fait remonter NSS
//    SPI1->CR1 &= ~0x0040;
//
//}

uint16_t Signal_triangle(uint8_t *default_bits, uint8_t *bits, uint8_t n, uint8_t i)
{
    uint8_t value = 0;
	uint8_t mid = 0;

	if (n%2)
	{
		mid = (n+1)/2;
	}
	else
	{
		mid = n/2;
	}

	if(i<= mid)
	{
//		Valeur entre 0 et 3.3V
//		value = 255*i/mid;

//		Valeur entre 1.7 et 3.3V, centré en 2.5V
		value = 255/2 + (1.6/3.3) * 255*i/mid;
	}


	else if(i > mid)
	{
//		Value between 0 and 3.3V
//		value = 255*(2*mid - i)/mid;

//		Value between 1.7 and 3.3V, centered around 2.5V
		value = 255/2 + (1.6/3.3) * 255*(2*mid - i)/mid;
	}

	dec_to_bin(value, bits);
	copy_in_vector(bits, default_bits);

	return bin_to_dec(default_bits);
}

uint16_t Signal_sine(uint8_t *default_bits, uint8_t *bits, uint8_t n, uint8_t i)
{

    uint8_t value = 0;
    float angle = 0;

	angle = (2*PI*i) / (float) n;

//	Value between 0 and 3.3V
//	value = (255/2) * (sin(angle) + 1);

//	Value between 1.7 and 3.3V, centered around 2.5V
	value = 255/2 + (1.6/3.3) * (255/2) * (sin(angle) + 1);

	dec_to_bin(value, bits);
	copy_in_vector(bits, default_bits);

	return bin_to_dec(default_bits);
}

void dec_to_bin(uint8_t value, uint8_t *bits)
{
    for (int i = 7; i >= 0; i--)
    {
        bits[7 - i] = (value & (1 << i)) ? 1 : 0;
    }
}
void copy_in_vector(uint8_t *bits, uint8_t *default_bits)
{
	for (int i = 0; i <= 7; i++)
	{
		default_bits[4 + i] = bits[i];
	}
}
void copy_in_vector_r(uint8_t *bits_r, uint8_t *default_bits_r)
{
	for (int i = 0; i <= 7; i++)
	{
		default_bits[8 + i] = bits[i];
	}
}
uint16_t bin_to_dec(uint8_t *bits)
{
    uint16_t value = 0;
    for (int i = 0; i < 16; i++)
    {
        value |= (bits[i] & 0x01) << (15 - i);
    }
    return value;
}

void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
{
	switch (GPIO_Pin)
	{
		case GPIO_PIN_8:
			flag_change_signal = 1;
			sprintf(uart_buffer, "button change signal was pressed\r\n");
			HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);
			break;
		case GPIO_PIN_9:
			flag_freq_decrease = 1;
			sprintf(uart_buffer, "button decrease freq signal was pressed\r\n");
			HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);
			break;
		case GPIO_PIN_10:
			flag_freq_increase = 1;
			sprintf(uart_buffer, "button increase freq signal was pressed\r\n");
			HAL_UART_Transmit(&huart2, (uint8_t *)uart_buffer, strlen(uart_buffer), HAL_MAX_DELAY);
			break;
	}

}

//void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
//{
//    if (htim->Instance == TIM17)
//    {
//        flag_tim17_overflow = 1;
//    }
//}

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