/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.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 ---------------------------------------------------------*/
IWDG_HandleTypeDef hiwdg;

TIM_HandleTypeDef htim1;

UART_HandleTypeDef huart2;

/* USER CODE BEGIN PV */
uint8_t percent = 100;
uint8_t step = 1;
uint8_t volatile RX_Buf[128], RX_Empty = 0, RX_Busy = 0; //bufor do odbierania, wskaźniki empty i busy dla bufora odbierającego
uint8_t volatile TX_Buf[128], TX_Empty = 0, TX_Busy = 0; //bufor do wysyłania, wskaźniki empty i busy dla bufora wysyłającego
int bufSize = 128, comSize = 64, i = 0, j = 0; //rozmiar buforów, rozmiar tablicy pomocniczej, zmienne pomocnicze do przechodzenia po tablicach
int ledTimeOn = 0, ledTimeOff = 0, ledBlinkCount = 0, time, timer; //zmienne przechowujące czas włączenia diody, wyłączenia diody, ilość mrugnięć i zmienne przechowujące czas, który upłynął od początku zwracany przez HAL_GetTick(), odpowiedzialne za opóźnienia
uint8_t COM[64];
uint8_t pulseMode=0;
/* USER CODE END PV */

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


void IWDG_Refresh(void){
    if(HAL_IWDG_Refresh(&hiwdg) != HAL_OK)
    {
        //Error_SetMessage("WATCHDOG CANT REFRESH\r\n");
        Error_Handler();
    }
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){ //funkcja obsługująca przerwanie po odebraniu znaków przez HAL_UART_Receive_IT
    if(huart->Instance==USART2){ //sprawdzenie czy przerwanie wywołał USART2
        RX_Empty++; //przesunięcie wskaźnika empty o jeden po odebraniu bajta
        if(RX_Empty>=bufSize) RX_Empty = 0; //jeżeli wskaźnik empty wychodzi poza rozmiar bufora przesunięcie go na początek
        HAL_UART_Receive_IT(&huart2,&RX_Buf[RX_Empty],1); //odebranie kolejnego bajta znaków i wpisanie go do bufora od pustego miejsca
    }
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart){ //funkcja obsługująca przerwanie po wysłaniu znaków przez HAL_UART_Transmit_IT
    if(huart->Instance==USART2){ //sprawdzenie czy przerwanie wywołał USART2
        if(TX_Busy!=TX_Empty){ //sprawdzenie czy w buforze nadal coś się znajduje
            TX_Busy++; //jeżeli tak to przechodzimy do następnego bajta - przesuwamy wskaźnik busy dalej
            if(TX_Busy>=bufSize) TX_Empty=0; //jeżeli wskaźnik busy wychodzi poza rozmiar bufora przesunięcie go na początek
            HAL_UART_Transmit_IT(&huart2,&TX_Buf[TX_Busy],1); //wysłanie kolejnego bajta od pierwszego zajętego miejsca w buforze
        }
    }
}

/*-------------OBSŁUGA WYSYŁANIA-------------*/
void USART2_fsend(char* format, ...)
{
    char tmp_rs[128];
    int i;
    __IO int idx;

    va_list arglist;
    va_start(arglist,format);
    vsprintf(tmp_rs,format,arglist);
    va_end(arglist);

    idx=TX_Empty;

    for(i=0;i<strlen(tmp_rs);i++)
    {
        TX_Buf[idx]=tmp_rs[i];
        idx++;
        if(idx >= bufSize)idx=0;
    }
    __disable_irq();

    if((TX_Empty==TX_Busy)&&(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TXE)==SET))
    {
        TX_Empty=idx;
        uint8_t tmp=TX_Buf[TX_Busy];
        TX_Busy++;
        if(TX_Busy >= bufSize) TX_Busy=0;
        HAL_UART_Transmit_IT(&huart2, &tmp, 1);
    }
    else
    {
        TX_Empty=idx;
    }
    __enable_irq();
}//fsend

void parse() {
    if (RX_Busy != RX_Empty) { //jeżeli coś znajduje się w buforze odbierającym
        if(RX_Buf[RX_Busy] != ';') { //jeżeli element nie jest średnikiem
            COM[j] = RX_Buf[RX_Busy]; //wpisanie danej z bufora do tablicy przechowującej komendy
            j++; //przejście do kolejnego elementu w tablicy komend
            if (j >= bufSize) j = 0; //jeżeli wskaźnik na element w tablicy komend wychodzi poza jej rozmiar przesunięcie go na początek
        } else {
            COM[j] = '\0'; //dodanie 0 na końcu w celu umożliwienia interpretacji jako łańcuch
            j = 0; //wyzerowanie wskaźnika w tablicy komend
            pulseMode = 0;
            ledBlinkCount = 0;
            if(strcmp(COM, "LED[ON]") == 0) { //sprawdzanie czy elementy w tablicy komend są zgodne z poszczególnymi wzorcami - włączanie, wyłączanie i mruganie diodą
                HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_SET); //ustawienie pinu diody
            } else if(strcmp(COM, "LED[OFF]") == 0) {
                HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET); //resetowanie pinu diody
            } else if((sscanf(COM, "LED[BLINK,%d,%d,%d]", &ledTimeOn, &ledTimeOff, &ledBlinkCount)) == 3) { //sprawdzanie czy komenda BLINK zawiera kolejno trzy parametry i przypisanie ich do zmiennych
                time = HAL_GetTick(); //pobranie wartości ticków w milisekundach
            } else if(strcmp(COM, "LED[PULSE]") == 0){
                pulseMode=1;
            } else{
                USART2_fsend("ERR\n\r"); //zwrócenie błędu jeżeli żadna z powyższych komend nie została dopasowana
            }
        }

        RX_Busy++; //zwiększenie wskaźnika busy (przejście na następny element do odczytu)
        if(RX_Busy >= bufSize) RX_Busy = 0;//jeżeli wskaźnik wykracza poza rozmiar bufora przesunięcie go na początek
    }
}

void blinker(void){
    if(ledBlinkCount > 0) { //jeżeli wykryto komendę mrugania
        timer = HAL_GetTick() - time; //ustawienie timera

        if(timer <= ledTimeOn) { //ustawianie diody dopóki czas nie osiągnie wartości przekazanej w parametrze komendy
            HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_SET);
        } else if(timer <= (ledTimeOn + ledTimeOff)) { //resetowanie diody dopóki czas nie osiągnie sum wartości włączenia i wyłączenia diody przekazanej w parametrze komendy
            HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
        }

        if(timer > (ledTimeOn + ledTimeOff)) { //po zapaleniu i zgaszeniu diody pobiera nowy czas i zmniejsza licznik mrugnięć
            time = HAL_GetTick();
            ledBlinkCount--;
        }
    }
}

void pin8Topin5(void){
    if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8)){
              HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, SET);
          }else{
              HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, RESET);
          }
}

void pulse(TIM_OC_InitTypeDef oc){
    if((HAL_GetTick()-xD)>30){

              oc.Pulse = percent;
              HAL_TIM_PWM_ConfigChannel(&htim1, &oc, TIM_CHANNEL_1);
              if( ( ( percent + step ) < 0 ) || ( ( percent + step ) > 100 ) )
              {
                  step = -step;
              }
              percent += step;

              xD = HAL_GetTick();
          }
}


/* 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 */
if(__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET)
{
    USART2_fsend("Watchdog");
}
  /* 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_TIM1_Init();
  MX_USART2_UART_Init();
  MX_IWDG_Init();
  /* USER CODE BEGIN 2 */
  USART2_fsend("Hello, I am STM32 !!!\n\r"); //wysłanie wstępnej wiadomości
  HAL_UART_Receive_IT(&huart2, &RX_Buf[RX_Empty], 1); //pierwsze uruchomienie funkcji do nasłuchiwania na USART z wykorzystaniem przerwań
  timer = HAL_GetTick(); //pobranie wartości ticków w milisekundach
  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
  xD=HAL_GetTick();
  TIM_OC_InitTypeDef oc;
  oc.OCMode = TIM_OCMODE_PWM1;
  oc.OCPolarity = TIM_OCPOLARITY_HIGH;
  oc.OCFastMode = TIM_OCFAST_DISABLE;
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */

      IWDG_Refresh();
      pin8Topin5();
      parse(oc);
      blinker();

      if(pulseMode==1){

      if((HAL_GetTick()-timer)>30){

          oc.Pulse = percent;
          HAL_TIM_PWM_ConfigChannel(&htim1, &oc, TIM_CHANNEL_1);
          if( ( ( percent + step ) < 0 ) || ( ( percent + step ) > 100 ) )
          {
              step = -step;
          }
          percent += step;

          timer = HAL_GetTick();
      }
      }

  }
  /* 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 CPU, AHB and APB busses clocks
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_LSI;
  RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses 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();
  }
}

/**
  * @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 */
  hiwdg.Instance = IWDG;
  hiwdg.Init.Prescaler = IWDG_PRESCALER_32;
  hiwdg.Init.Reload = 4095;
  if (HAL_IWDG_Init(&hiwdg) != HAL_OK)
  {
    USART2_fsend("Blad inicjacji watchdoga)");
    Error_Handler();
  }
  /* USER CODE BEGIN IWDG_Init 2 */

  /* USER CODE END IWDG_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 oc;
  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 = 100;
  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.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  oc.OCMode = TIM_OCMODE_PWM1;
  oc.Pulse = 10;
  oc.OCPolarity = TIM_OCPOLARITY_HIGH;
  oc.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  oc.OCFastMode = TIM_OCFAST_DISABLE;
  oc.OCIdleState = TIM_OCIDLESTATE_RESET;
  oc.OCNIdleState = TIM_OCNIDLESTATE_RESET;

  if (HAL_TIM_PWM_ConfigChannel(&htim1, &oc, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Start(&htim1, 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.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;
  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};

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

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

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

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

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

}

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

  /* 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,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/