/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "iwdg.h"
#include "gpio.h"
#include "usart.h"
#include "navikit.h"
#include "coulomb.h"
#include "stdbool.h"
#include "adc.h"
#include "i2c.h"
#include "log.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 ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */

/* USER CODE END Variables */
/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
  .name = "defaultTask",
  .priority = (osPriority_t) osPriorityNormal,
  .stack_size = 128 * 4
};
/* Definitions for LedBlinkTask */
osThreadId_t LedBlinkTaskHandle;
const osThreadAttr_t LedBlinkTask_attributes = {
  .name = "LedBlinkTask",
  .priority = (osPriority_t) osPriorityLow,
  .stack_size = 128 * 4
};
/* Definitions for IWDGRefreshTask */
osThreadId_t IWDGRefreshTaskHandle;
const osThreadAttr_t IWDGRefreshTask_attributes = {
  .name = "IWDGRefreshTask",
  .priority = (osPriority_t) osPriorityHigh,
  .stack_size = 128 * 4
};
/* Definitions for EventDetect */
osThreadId_t EventDetectHandle;
const osThreadAttr_t EventDetect_attributes = {
  .name = "EventDetect",
  .priority = (osPriority_t) osPriorityLow,
  .stack_size = 128 * 4
};
/* Definitions for CoulombRead */
osThreadId_t CoulombReadHandle;
const osThreadAttr_t CoulombRead_attributes = {
  .name = "CoulombRead",
  .priority = (osPriority_t) osPriorityLow,
  .stack_size = 128 * 4
};
/* Definitions for StateSwitchTask */
osThreadId_t StateSwitchTaskHandle;
const osThreadAttr_t StateSwitchTask_attributes = {
  .name = "StateSwitchTask",
  .priority = (osPriority_t) osPriorityLow,
  .stack_size = 128 * 4
};
/* Definitions for PowerMonitTask */
osThreadId_t PowerMonitTaskHandle;
const osThreadAttr_t PowerMonitTask_attributes = {
  .name = "PowerMonitTask",
  .priority = (osPriority_t) osPriorityLow,
  .stack_size = 128 * 4
};

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */
void osEnterSleepState();
void osEnterRuningState();
/* USER CODE END FunctionPrototypes */

void StartDefaultTask(void *argument);
void StartLedBlinkTask(void *argument);
void StartIWDGRefreshTask(void *argument);
void StartEventDetect(void *argument);
void StartCoulombRead(void *argument);
void StartStateSwitchTask(void *argument);
void StartPowerMonitTask(void *argument);

extern void MX_USB_DEVICE_Init(void);
void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* Hook prototypes */
void configureTimerForRunTimeStats(void);
unsigned long getRunTimeCounterValue(void);
void vApplicationIdleHook(void);
void vApplicationTickHook(void);
void vApplicationStackOverflowHook(xTaskHandle xTask, signed char *pcTaskName);

/* USER CODE BEGIN 1 */
/* Functions needed when configGENERATE_RUN_TIME_STATS is on */
__weak void configureTimerForRunTimeStats(void)
{

}

__weak unsigned long getRunTimeCounterValue(void)
{
return 0;
}
/* USER CODE END 1 */

/* USER CODE BEGIN 2 */
void vApplicationIdleHook( void )
{
   /* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set
   to 1 in FreeRTOSConfig.h. It will be called on each iteration of the idle
   task. It is essential that code added to this hook function never attempts
   to block in any way (for example, call xQueueReceive() with a block time
   specified, or call vTaskDelay()). If the application makes use of the
   vTaskDelete() API function (as this demo application does) then it is also
   important that vApplicationIdleHook() is permitted to return to its calling
   function, because it is the responsibility of the idle task to clean up
   memory allocated by the kernel to any task that has since been deleted. */
}
/* USER CODE END 2 */

/* USER CODE BEGIN 3 */
void vApplicationTickHook( void )
{
   /* This function will be called by each tick interrupt if
   configUSE_TICK_HOOK is set to 1 in FreeRTOSConfig.h. User code can be
   added here, but the tick hook is called from an interrupt context, so
   code must not attempt to block, and only the interrupt safe FreeRTOS API
   functions can be used (those that end in FromISR()). */
}
/* USER CODE END 3 */

/* USER CODE BEGIN 4 */
void vApplicationStackOverflowHook(xTaskHandle xTask, signed char *pcTaskName)
{
   /* Run time stack overflow checking is performed if
   configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook function is
   called if a stack overflow is detected. */
}
/* USER CODE END 4 */

/* USER CODE BEGIN PREPOSTSLEEP */
__weak void PreSleepProcessing(uint32_t *ulExpectedIdleTime)
{
/* place for user code */
}

__weak void PostSleepProcessing(uint32_t *ulExpectedIdleTime)
{
/* place for user code */
}
/* USER CODE END PREPOSTSLEEP */

/**
  * @brief  FreeRTOS initialization
  * @param  None
  * @retval None
  */
void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */
       
  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* creation of defaultTask */
  defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

  /* creation of LedBlinkTask */
  LedBlinkTaskHandle = osThreadNew(StartLedBlinkTask, NULL, &LedBlinkTask_attributes);

  /* creation of IWDGRefreshTask */
//  IWDGRefreshTaskHandle = osThreadNew(StartIWDGRefreshTask, NULL, &IWDGRefreshTask_attributes);

  /* creation of EventDetect */
  EventDetectHandle = osThreadNew(StartEventDetect, NULL, &EventDetect_attributes);

  /* creation of CoulombRead */
  CoulombReadHandle = osThreadNew(StartCoulombRead, NULL, &CoulombRead_attributes);

  /* creation of StateSwitchTask */
  StateSwitchTaskHandle = osThreadNew(StartStateSwitchTask, NULL, &StateSwitchTask_attributes);

  /* creation of PowerMonitTask */
  PowerMonitTaskHandle = osThreadNew(StartPowerMonitTask, NULL, &PowerMonitTask_attributes);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */

  /* USER CODE END RTOS_THREADS */

  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */

}

/* USER CODE BEGIN Header_StartDefaultTask */
/**
  * @brief  Function implementing the defaultTask thread.
  * @param  argument: Not used 
  * @retval None
  */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
  /* init code for USB_DEVICE */
//  MX_USB_DEVICE_Init();
  /* USER CODE BEGIN StartDefaultTask */
 osVersion_t osVersion;
 char id_buf[20];
 unsigned char id_size=20;

	HAL_GPIO_WritePin(USB2_FS_ENUM_CTL_GPIO_Port,USB2_FS_ENUM_CTL_Pin, GPIO_PIN_SET);
	Beep(50);

	Log(info,"----------------------------------------------");
	Log(info,"Copyright (c) Powered by www.autolabor.com.cn");

	Log(info,"EC Firmware : %s[%s], build: %s, %s, by STD:%u",APP_VERSION,DEPLOY_MODE,__DATE__ ,__TIME__,__STDC_VERSION__  );
	Log(info,"HAL Version: %u ", HAL_GetHalVersion());
	Log(info,"Revision ID: %u ", HAL_GetREVID());
	Log(info,"Device ID: %u ", HAL_GetDEVID());
	Log(info,"Chip UID: %u%u%u ", HAL_GetUIDw0(),HAL_GetUIDw1(),HAL_GetUIDw2);

	if(osOK == osKernelGetInfo(&osVersion,id_buf,id_size)){
		Log(info,"OS Kernel Version: %u ", osVersion.kernel );
		Log(info,"OS Kernel ID: %s ",id_buf );
	}

	Log(info,"Core initial successfully");
	Log(info,"----------------------------------------------");
//	  osEnterSleepState();
  /* Infinite loop */
  for(;;)
  {
	osDelay(1000);

  }
  /* USER CODE END StartDefaultTask */
}

/* USER CODE BEGIN Header_StartLedBlinkTask */
/**
* @brief Function implementing the LedBlinkTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartLedBlinkTask */
void StartLedBlinkTask(void *argument)
{
  /* USER CODE BEGIN StartLedBlinkTask */
  /* Infinite loop */
	for(;;)
	{
		switch(NaviKit.sys.sta){
		case running:
    {
      if(HAL_GPIO_ReadPin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin))
        HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_RESET);//turn on power led
    
      if(HAL_GPIO_ReadPin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin) == GPIO_PIN_SET)//sys run led is off
      {
        HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_RESET);//turn on sys run led
        osDelay(50);
      }
      else
      {
        HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_SET);//turn off sys run led
        osDelay(300);
      }
    }break;
		case shutdown:
    {
      if(!HAL_GPIO_ReadPin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin))
        HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_SET);//turn off power led

      if(HAL_GPIO_ReadPin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin) == GPIO_PIN_SET)//sys run led is off
      {
        HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_RESET);//turn on sys run led
        osDelay(20);
      }
      else
      {
        HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_SET);//turn off sys run led
        osDelay(2000);
      }
    }break;
		case sleep:
    {//sleep mode
      for(uint16_t i=0;i<25;i++)
      {//20 light level
          for(uint16_t j=0;j<3;j++)
          {//the time length of every light level 
              HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_SET);
              HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_SET);
              osDelay(i);
              HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_RESET);
              HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_RESET);
              osDelay(25-i);
          } 
      }
      for(uint16_t i=0;i<25;i++)
      {
          for(uint16_t j=0;j<3;j++)
          {
              HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_SET);
              HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_SET);
              osDelay(25-i);
              HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_RESET);
              HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_RESET);
              osDelay(i);
          } 
      }
      
    }break;
		case dfu:
		{
			  if(HAL_GPIO_ReadPin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin) == GPIO_PIN_SET)//power led is off
			  {
				HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_RESET);//turn on power led
				HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_RESET);//turn on run led
				osDelay(300);
			  }
			  else
			  {
				HAL_GPIO_WritePin(SYS_POWER_LED_CTL_GPIO_Port,SYS_POWER_LED_CTL_Pin,GPIO_PIN_SET);//turn off sys run led
				HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_SET);//turn off run led
				osDelay(300);
			  }
		}break;
		case isp:
			break;
		}
	}
  /* USER CODE END StartLedBlinkTask */
}

/* USER CODE BEGIN Header_StartIWDGRefreshTask */
/**
* @brief Function implementing the IWDGRefreshTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartIWDGRefreshTask */
void StartIWDGRefreshTask(void *argument)
{
  /* USER CODE BEGIN StartIWDGRefreshTask */
  /* Infinite loop */
  for(;;)
  {
	HAL_IWDG_Refresh(&hiwdg);
	osDelay(1000);
  }
  /* USER CODE END StartIWDGRefreshTask */
}

/* USER CODE BEGIN Header_StartEventDetect */
/**
* @brief Function implementing the EventDetect thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartEventDetect */
void StartEventDetect(void *argument)
{
  /* USER CODE BEGIN StartEventDetect */
	osDelay(100);
  if(HAL_GPIO_ReadPin(SYS_CUSTOM_BTN_GPIO_Port,SYS_CUSTOM_BTN_Pin) == GPIO_PIN_RESET)
  {
      Log(debug,"Custom button has been pushed.");
      NaviKit.sys.next_sta = isp;
  }
  /* Infinite loop */
  for(;;)
  {

	  if(NaviKit.sys.power_btn == true)
	  {//power btn has been pushed
		  uint8_t count =0;
		  while(NaviKit.sys.power_btn && count<=10){
			  osDelay(100);
			  count ++;
		  }
		  if(count >10)
		  {//power btn has been pushed more than 1000 ms
		// while(NaviKit.sys.power_btn == true);//wait to release button
			  switch(NaviKit.sys.sta){
				  case running:{//system is running now, user request to shutdown
					  NaviKit.sys.next_sta = shutdown;
				  }break;
				  case shutdown:{//system is shutdown now , user request to power on
					  NaviKit.sys.next_sta = running;
				  }break;
				  case dfu:{
					  NaviKit.sys.next_sta = shutdown;
				  }break;
				  case sleep:{
					  NaviKit.sys.next_sta = running;
				  }break;
			  }
		  }
	  else
	  {
		  //sleep mode is unused
	//    	  if(NaviKit.sys.sta == runing)
	//          NaviKit.sys.sta = sleep;
	//    	  else if(NaviKit.sys.sta == sleep)
	//          NaviKit.sys.sta = runing;
	  }
	  }
	  if(NaviKit.sys.custom_btn == true )
	  {//custom button has been pushed
		  uint8_t count =0;
		  while(NaviKit.sys.custom_btn  && count<=20){
			  osDelay(100);
			  count ++;
		  }
		  if(count > 20 )
		  {//custom button has been pushed over 1000 ms
			  if((NaviKit.sys.power_btn == true) && (NaviKit.sys.sta == shutdown))//into dfu state
				  NaviKit.sys.next_sta = dfu;
			  else//TODO: force restart
				  NaviKit.sys.next_sta = shutdown;
//			  if(NaviKit.sys.sta == runing)
//				  NaviKit.sys.next_sta = shutdown;
//			  else if(NaviKit.sys.sta == shutdown)
//				  NaviKit.sys.next_sta = runing;
		  }
	  }

  osDelay(10);
  }
  /* USER CODE END StartEventDetect */
}

/* USER CODE BEGIN Header_StartCoulombRead */
/**
* @brief Function implementing the CoulombRead thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartCoulombRead */
void StartCoulombRead(void *argument)
{
  /* USER CODE BEGIN StartCoulombRead */
	//写寄存器方法
  coulomb_write_config_load();
  coulomb_write_config_actual_to_raw();
  coulomb_write_config();
  //读寄存器方法
  coulomb_read_status_and_config();
  coulomb_read_status_raw_to_actual();
  coulomb_read_config_raw_to_actual();

  /* Infinite loop */
  for(;;)
  {
    coulomb_read_status_and_config();
    coulomb_read_status_raw_to_actual();
	  if(NaviKit.sys.sta == running)
		  osDelay(500);
	  else
		  osDelay(5000);
  }
  /* USER CODE END StartCoulombRead */
}

/* USER CODE BEGIN Header_StartStateSwitchTask */
/**
* @brief Function implementing the StateSwitchTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartStateSwitchTask */
void StartStateSwitchTask(void *argument)
{
  /* USER CODE BEGIN StartStateSwitchTask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(10);
	  if(NaviKit.sys.next_sta != NaviKit.sys.sta)
	  {
		  switch(NaviKit.sys.next_sta)
		  {
			  case shutdown:
			  {//only from running state
			  if((NaviKit.sys.sta == running)){// && (NaviKit.som.shutdown_req == true)
				  enter_shutdown_state();
//			  	  osEnterSleepState();
			  }
          }break;
			  case running:
			  {//from sleep and shutdown state
          enter_runing_state();
          }break;
			  case sleep:
			  {//only form running state
          if(NaviKit.sys.sta == running)
            enter_sleep_state();

          }break;
			  case dfu:
			  {
				  enter_dfu_state();
			  }break;
        case isp:
        {
          enter_isp_state();
        }break;
		  }
		  NaviKit.sys.sta = NaviKit.sys.next_sta;
	  }
  }
  /* USER CODE END StartStateSwitchTask */
}

/* USER CODE BEGIN Header_StartPowerMonitTask */
/**
* @brief Function: Monit som power status and PMB status
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartPowerMonitTask */
void StartPowerMonitTask(void *argument)
{
  /* USER CODE BEGIN StartPowerMonitTask */
	HAL_ADCEx_Calibration_Start(&hadc1);
	HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&(NaviKit.pmb.rails.adc), ADC_CH_COUNT);
  /* Infinite loop */
  for(;;)
  {
	    osDelay(5000);
	  if(NaviKit.sys.sta == running){
			if(NaviKit.pmb.rails.out_24v > 26.4 || NaviKit.pmb.rails.out_24v < 21.6){
				 Log(error,"24V(±10%) power rail exception:%dV",NaviKit.pmb.rails.out_24v);
			}
			if(NaviKit.pmb.rails.out_5v > 5.5 || NaviKit.pmb.rails.out_5v < 4.5){
				 Log(error,"5V(±10%) power rail exception:%dV",NaviKit.pmb.rails.out_5v);
			}
			if(NaviKit.pmb.rails.out_12v > 13.2 || NaviKit.pmb.rails.out_12v < 10.8){
				 Log(error ,"12V(±10%) power rail exception:%dV",NaviKit.pmb.rails.out_12v);
			}
			if(NaviKit.pmb.rails.bkp_bat < 9.5){
				 Log(warning,"Backup power is not online");
			}
			if(NaviKit.pmb.rails.main_pwr < 19){
				Beep(200);
				 Log(warning,"Main power has been lost, please shutdown computer as soon as possible");
		 }
	  }
		if(NaviKit.pmb.rails.bkp_bat > 15){
			 Log(error,"Backup power is exception:%dV",NaviKit.pmb.rails.bkp_bat);
				Beep(200);
		}
		if(NaviKit.pmb.rails.main_pwr > 30){
			Beep(200);
			 Log(error,"Backup power is exception:%dV",NaviKit.pmb.rails.main_pwr);
		}

  }
  /* USER CODE END StartPowerMonitTask */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

//os enter sleep state for save power
void osEnterSleepState(){
  Log(info,"EC Enter Sleep State");
  HAL_GPIO_WritePin(SYS_RUN_LED_CTL_GPIO_Port,SYS_RUN_LED_CTL_Pin,GPIO_PIN_SET);//turn off sys run led
  vTaskSuspendAll();
//  osKernelLock();
  HAL_SuspendTick();
//  MX_USB_DEVICE_DeInit();
  HAL_I2C_MspDeInit(&hi2c1);
  HAL_ADC_MspDeInit(&hadc1);
  HAL_ADC_Stop_DMA(&hadc1);
  HAL_PWR_EnableSleepOnExit();//for rtos application,enter sleep after interrupt end
  HAL_PWR_EnterSLEEPMode(0,PWR_SLEEPENTRY_WFE);
}
void osEnterRuningState(){
  HAL_ResumeTick();
  //  MX_USB_DEVICE_Init();
  HAL_I2C_MspInit(&hi2c1);
  HAL_ADC_MspInit(&hadc1);
	HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&(NaviKit.pmb.rails.adc), ADC_CH_COUNT);
	__set_CONTROL(0);
	xTaskResumeAll();
//	osKernelUnlock();
	NaviKit.sys.next_sta = running;
  Log(info,"EC Enter Runing State");
}
//printf redirect
#ifdef __GNUC__
//#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#define PUTCHAR_PROTOTYPE int putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif

PUTCHAR_PROTOTYPE
{
	while(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX){}
	HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,1);
	return ch;
}

/* USER CODE END Application */

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