/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 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 "usart.h"

/* USER CODE BEGIN 0 */
void    Rx_Interrupt_IT(UART_HandleTypeDef *huart,uint8_t rx_data);

#define   MAX_TXBUFFER_SIZE_UART2   64    //must be 2,4,8,16,32,64,128,256(max)
#define   MAX_RXBUFFER_SIZE_UART2   256   //must be 2,4,8,16,32,64,128,256,...
#define   MAX_TXBUFFER_SIZE_UART3   64    //must be 2,4,8,16,32,64,128,256(max)
#define   MAX_RXBUFFER_SIZE_UART3   256   //must be 2,4,8,16,32,64,128,256,...
#define   MAX_PACKET_SIZE           128

//uart 2
struct {
  uint8_t head;
  uint8_t tail;
  uint8_t buffer[MAX_TXBUFFER_SIZE_UART2][MAX_PACKET_SIZE];
  uint8_t size[MAX_TXBUFFER_SIZE_UART2];
} uart_tx_uart2;

struct {
  uint16_t head;
  uint16_t tail;
  uint16_t buffer[MAX_RXBUFFER_SIZE_UART2];
} uart_rx_uart2;

//uart 3
struct {
  uint8_t head;
  uint8_t tail;
  uint8_t buffer[MAX_TXBUFFER_SIZE_UART3][MAX_PACKET_SIZE];
  uint8_t size[MAX_TXBUFFER_SIZE_UART3];
} uart_tx_uart3;

struct {
  uint16_t head;
  uint16_t tail;
  uint16_t buffer[MAX_RXBUFFER_SIZE_UART3];
} uart_rx_uart3;

/* USER CODE END 0 */

UART_HandleTypeDef huart2;
UART_HandleTypeDef huart3;

/* USART2 init function */

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 */
  uint8_t rx_data=0;
  Rx_Interrupt_IT(&huart2,rx_data);
  /* USER CODE END USART2_Init 2 */

}
/* USART3 init function */

void MX_USART3_UART_Init(void)
{

  /* USER CODE BEGIN USART3_Init 0 */

  /* USER CODE END USART3_Init 0 */

  /* USER CODE BEGIN USART3_Init 1 */

  /* USER CODE END USART3_Init 1 */
  huart3.Instance = USART3;
//  huart3.Init.BaudRate = 9600;
//  huart3.Init.BaudRate = 19200;
//  huart3.Init.BaudRate = 38400;
//  huart3.Init.BaudRate = 57600;
  huart3.Init.BaudRate = 115200;
//  huart3.Init.BaudRate = 230400;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART3_Init 2 */
  uint8_t rx_data=0;
  Rx_Interrupt_IT(&huart3,rx_data);
  /* USER CODE END USART3_Init 2 */

}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspInit 0 */

  /* USER CODE END USART2_MspInit 0 */
    /* USART2 clock enable */
    __HAL_RCC_USART2_CLK_ENABLE();

    __HAL_RCC_GPIOD_CLK_ENABLE();
    /**USART2 GPIO Configuration
    PD5     ------> USART2_TX
    PD6     ------> USART2_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

    /* USART2 interrupt Init */
    HAL_NVIC_SetPriority(USART2_IRQn, 10, 0);
    HAL_NVIC_EnableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspInit 1 */

  /* USER CODE END USART2_MspInit 1 */
  }
  else if(uartHandle->Instance==USART3)
  {
  /* USER CODE BEGIN USART3_MspInit 0 */

  /* USER CODE END USART3_MspInit 0 */
    /* USART3 clock enable */
    __HAL_RCC_USART3_CLK_ENABLE();

#if   HW_VER >=3
    __HAL_RCC_GPIOD_CLK_ENABLE();
    /**USART3 GPIO Configuration
    PD8      ------> USART3_TX
    PD9      ------> USART3_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
//    BLE_Init();                         //BLE_RESET_PIN
#else
    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**USART3 GPIO Configuration
    PB10     ------> USART3_TX
    PB11     ------> USART3_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
#endif

    /* USART3 interrupt Init */
//    HAL_NVIC_SetPriority(USART3_IRQn, 10, 0);   // 0으로 낮춰보기 (HSW 24.02.20)
    HAL_NVIC_SetPriority(USART3_IRQn, 0, 1);   // 0으로 낮춰보기
    HAL_NVIC_EnableIRQ(USART3_IRQn);
  /* USER CODE BEGIN USART3_MspInit 1 */

  /* USER CODE END USART3_MspInit 1 */
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{

  if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspDeInit 0 */

  /* USER CODE END USART2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART2_CLK_DISABLE();

    /**USART2 GPIO Configuration
    PD5     ------> USART2_TX
    PD6     ------> USART2_RX
    */
    HAL_GPIO_DeInit(GPIOD, GPIO_PIN_5|GPIO_PIN_6);

    /* USART2 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspDeInit 1 */

  /* USER CODE END USART2_MspDeInit 1 */
  }
  else if(uartHandle->Instance==USART3)
  {
  /* USER CODE BEGIN USART3_MspDeInit 0 */

  /* USER CODE END USART3_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART3_CLK_DISABLE();

    /**USART3 GPIO Configuration
    PB10     ------> USART3_TX
    PB11     ------> USART3_RX
    */
#if   HW_VER >=3
    HAL_GPIO_DeInit(GPIOD, GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10);
#else
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10|GPIO_PIN_11);
#endif
    /* USART3 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART3_IRQn);
  /* USER CODE BEGIN USART3_MspDeInit 1 */

  /* USER CODE END USART3_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */



void UART_PutData(UART_HandleTypeDef *huart, uint8_t *data, uint8_t size )  //in queue
{
  uint8_t *tx;
  if(size==0){                //string size check
    uint8_t *str_data=data;
    while(*str_data++!='\0') {
      if(++size==MAX_PACKET_SIZE) break;
    }
  }
  if(huart->Instance==USART2) {
  #if MAX_TXBUFFER_SIZE_UART2 != 0x100
    if( uart_tx_uart2.head!=((uart_tx_uart2.tail+1)&(MAX_TXBUFFER_SIZE_UART2-1)) )  //not full
  #else
    if( uart_tx_uart2.head!=(uart_tx_uart2.tail+1) )
  #endif
    {
      for(uint8_t i=0; i<size; i++) {          //data copy
        uart_tx_uart2.buffer[uart_tx_uart2.tail][i]=data[i];
      }
      uart_tx_uart2.size[uart_tx_uart2.tail]=size;
      HAL_NVIC_DisableIRQ(USART2_IRQn);
      uart_tx_uart2.tail++;
    #if MAX_TXBUFFER_SIZE_UART2 != 0x100
      uart_tx_uart2.tail &= MAX_TXBUFFER_SIZE_UART2-1;    //because MAX_TXBUFFER_SIZE != 0x100
    #endif
      HAL_NVIC_EnableIRQ(USART2_IRQn);
    }
    HAL_NVIC_DisableIRQ(USART2_IRQn);
    if(huart2.gState==HAL_UART_STATE_READY) {    //uart ready check
      tx=uart_tx_uart2.buffer[uart_tx_uart2.head];
      uart_tx_uart2.head++;
    #if MAX_TXBUFFER_SIZE_UART2 != 0x100
      uart_tx_uart2.head &= MAX_TXBUFFER_SIZE_UART2-1;    //because MAX_TXBUFFER_SIZE != 0x100
    #endif
      HAL_NVIC_EnableIRQ(USART2_IRQn);
      HAL_UART_Transmit_IT(huart, tx, size);
    }
    HAL_NVIC_EnableIRQ(USART2_IRQn);
  }
  if(huart->Instance==USART3) {
  #if MAX_TXBUFFER_SIZE_UART3 != 0x100
    if( uart_tx_uart3.head!=((uart_tx_uart3.tail+1)&(MAX_TXBUFFER_SIZE_UART3-1)) )  //not full
  #else
    if( uart_tx_uart3.head!=(uart_tx_uar3.tail+1) )
  #endif
    {
      for(uint8_t i=0; i<size; i++) {          //data copy
        uart_tx_uart3.buffer[uart_tx_uart3.tail][i]=data[i];
      }
      uart_tx_uart3.size[uart_tx_uart3.tail]=size;
      HAL_NVIC_DisableIRQ(USART3_IRQn);
      uart_tx_uart3.tail++;
    #if MAX_TXBUFFER_SIZE_UART3 != 0x100
      uart_tx_uart3.tail &= MAX_TXBUFFER_SIZE_UART3-1;    //because MAX_TXBUFFER_SIZE != 0x100
    #endif
      HAL_NVIC_EnableIRQ(USART3_IRQn);
    }
    HAL_NVIC_DisableIRQ(USART3_IRQn);
    if(huart3.gState==HAL_UART_STATE_READY) {    //uart ready check
      tx=uart_tx_uart3.buffer[uart_tx_uart3.head];
      uart_tx_uart3.head++;
    #if MAX_TXBUFFER_SIZE_UART3 != 0x100
      uart_tx_uart3.head &= MAX_TXBUFFER_SIZE_UART3-1;    //because MAX_TXBUFFER_SIZE != 0x100
    #endif
      HAL_NVIC_EnableIRQ(USART3_IRQn);
      HAL_UART_Transmit_IT(huart, tx, size);
    }
    HAL_NVIC_EnableIRQ(USART3_IRQn);
  }
}

//-------interrupt tx, pull out data in queue buffer(dequeue)---------
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  uint8_t *tx;
  uint8_t size;
  if(huart->Instance==USART2) {
    if(uart_tx_uart2.head!=uart_tx_uart2.tail) {      //not empty
      tx=uart_tx_uart2.buffer[uart_tx_uart2.head];
      size=uart_tx_uart2.size[uart_tx_uart2.head];
      uart_tx_uart2.head++;
    #if MAX_TXBUFFER_SIZE_UART2 != 0x100
      uart_tx_uart2.head &= MAX_TXBUFFER_SIZE_UART2-1;
    #endif
      HAL_UART_Transmit_IT(&huart2, tx, size);
    }
  }
  if(huart->Instance==USART3) {
    if(uart_tx_uart3.head!=uart_tx_uart3.tail) {      //not empty
      tx=uart_tx_uart3.buffer[uart_tx_uart3.head];
      size=uart_tx_uart3.size[uart_tx_uart3.head];
      uart_tx_uart3.head++;
    #if MAX_TXBUFFER_SIZE_UART3 != 0x100
      uart_tx_uart3.head &= MAX_TXBUFFER_SIZE_UART3-1;
    #endif
      HAL_UART_Transmit_IT(huart, tx, size);
    }
  }
}

//------interrupt rx, receive data-------------------------------
void Rx_Interrupt_IT(UART_HandleTypeDef *huart,uint8_t rx_data)
{
  HAL_UART_Receive_IT(huart, &rx_data, 1);
}

//################################################################################
//
//    you must change the "UART_Receive_IT" function (see below)
//    the "UART_Receive_IT" function is in the "stm32f7xx_hal_uart.c" file
//
//################################################################################
/*
static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
{
  HAL_UART_RxCpltCallback(huart);       //insert
  return HAL_OK;                        //insert
  uint8_t  *pdata8bits;

  ...
  ...
  ...
}
*/

//---------interrupt rx, data in queue buffer(enqueue) -------------
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Check that a Rx process is ongoing */
  if(huart->Instance==USART2) {
    if(uart_rx_uart2.head!=((uart_rx_uart2.tail+1)&(MAX_RXBUFFER_SIZE_UART2-1)) ) {     //if not full
      uart_rx_uart2.buffer[uart_rx_uart2.tail]=(uint8_t) READ_REG(huart->Instance->DR); //enqueue
      uart_rx_uart2.tail++;
      uart_rx_uart2.tail &= MAX_RXBUFFER_SIZE_UART2-1;
    }
  }
  if(huart->Instance==USART3) {
    if(uart_rx_uart3.head!=((uart_rx_uart3.tail+1)&(MAX_RXBUFFER_SIZE_UART3-1)) ) {     //if not full
      uart_rx_uart3.buffer[uart_rx_uart3.tail]=(uint8_t) READ_REG(huart->Instance->DR); //enqueue
      uart_rx_uart3.tail++;
      uart_rx_uart3.tail &= MAX_RXBUFFER_SIZE_UART3-1;
    }
  }
}

int16_t UART_Getc(UART_HandleTypeDef *huart)
{
  uint8_t rcv_data;

  if(huart->Instance==USART2) {
    HAL_NVIC_DisableIRQ(USART2_IRQn);         //disable
    if(uart_rx_uart2.head!=uart_rx_uart2.tail) {          //if not empty
      rcv_data=uart_rx_uart2.buffer[uart_rx_uart2.head++];  //dequeue
      uart_rx_uart2.head &= MAX_RXBUFFER_SIZE_UART2-1;

      HAL_NVIC_EnableIRQ(USART2_IRQn);        //enable
      return rcv_data;
    }
    else {
      HAL_NVIC_EnableIRQ(USART2_IRQn);
      return (int16_t)-1;
    }
  }
  if(huart->Instance==USART3) {
    HAL_NVIC_DisableIRQ(USART3_IRQn);         //disable
    if(uart_rx_uart3.head!=uart_rx_uart3.tail) {          //if not empty
      rcv_data=uart_rx_uart3.buffer[uart_rx_uart3.head++];  //dequeue
      uart_rx_uart3.head &= MAX_RXBUFFER_SIZE_UART3-1;

      HAL_NVIC_EnableIRQ(USART3_IRQn);        //enable
      return rcv_data;
    }
    else {
      HAL_NVIC_EnableIRQ(USART3_IRQn);
      return (int16_t)-1;
    }
  }
  return -1;
}

uint8_t UART_Getch(UART_HandleTypeDef *huart)
{
  uint8_t rcv_data;

  if(huart->Instance==USART2) {
    while(1) {
      HAL_NVIC_DisableIRQ(USART2_IRQn);
      if(uart_rx_uart2.head!=uart_rx_uart2.tail) {
        rcv_data=uart_rx_uart2.buffer[uart_rx_uart2.head++];
        uart_rx_uart2.head &= MAX_RXBUFFER_SIZE_UART2-1;

        HAL_NVIC_EnableIRQ(USART2_IRQn);
        return rcv_data;
      }
      HAL_NVIC_EnableIRQ(USART2_IRQn);
    }
  }
  if(huart->Instance==USART3) {
    while(1) {
      HAL_NVIC_DisableIRQ(USART3_IRQn);
      if(uart_rx_uart3.head!=uart_rx_uart3.tail) {
        rcv_data=uart_rx_uart3.buffer[uart_rx_uart3.head++];
        uart_rx_uart3.head &= MAX_RXBUFFER_SIZE_UART3-1;

        HAL_NVIC_EnableIRQ(USART3_IRQn);
        return rcv_data;
      }
      HAL_NVIC_EnableIRQ(USART3_IRQn);
    }
  }
  return 0xFF;
}

//----- data size check -------------------------------
uint16_t UART_Available(UART_HandleTypeDef *huart)
{
  if(huart->Instance==USART2) {
    uint8_t data_size=uart_rx_uart2.tail-uart_rx_uart2.head;
    data_size &= MAX_RXBUFFER_SIZE_UART2-1;
    return data_size;
  }
  if(huart->Instance==USART3) {
    uint8_t data_size=uart_rx_uart3.tail-uart_rx_uart3.head;
    data_size &= MAX_RXBUFFER_SIZE_UART3-1;
    return data_size;
  }
  return 0;
}

#include <stdarg.h>
#include <string.h>
#include <stdio.h>
//----- string output ----------------------------------
void UART_printf(UART_HandleTypeDef *huart, char* inbuf, ...)
{
  uint8_t prbuffer[255];

  va_list pstart;
  va_start(pstart, inbuf);
  vsprintf((char*)prbuffer,inbuf,pstart);
  va_end(pstart);

  UART_Puts(huart,prbuffer);

}

void UART2_printf(char* inbuf, ...)
{
  uint8_t prbuffer[255];

  va_list pstart;
  va_start(pstart, inbuf);
  vsprintf((char*)prbuffer,inbuf,pstart);
  va_end(pstart);

  UART_Puts(&huart2,prbuffer);
}

void UART3_printf(char* inbuf, ...)
{
  uint8_t prbuffer[255];

  va_list pstart;
  va_start(pstart, inbuf);
  vsprintf((char*)prbuffer,inbuf,pstart);
  va_end(pstart);

  UART_Puts(&huart3,prbuffer);
}
void Debug_UART3_printf(char* inbuf, ...) // 충돌방지를 위해 선택적 출력용 (250705)

{
  if(!DebugingPrintActive) return;
  uint8_t prbuffer[255];

  va_list pstart;
  va_start(pstart, inbuf);
  vsprintf((char*)prbuffer,inbuf,pstart);
  va_end(pstart);

  UART_Puts(&huart3,prbuffer);
}

void Dummy_printf(char* inbuf, ...)
{
  ;
}

int16_t UART_Getc_NoClear(UART_HandleTypeDef *huart,uint16_t pos)
{
  uint8_t rcv_data;

  if(huart->Instance==USART2) {
    if(UART_Available(&huart2)<=pos)    return (int16_t)-1;
    else
    {
      rcv_data=uart_rx_uart2.buffer[(uart_rx_uart2.head+pos)&(MAX_RXBUFFER_SIZE_UART2-1)];
      return rcv_data;
    }
  }
  if(huart->Instance==USART3) {
    if(UART_Available(&huart3)<=pos)    return (int16_t)-1;
    else
    {
      rcv_data=uart_rx_uart3.buffer[(uart_rx_uart3.head+pos)&(MAX_RXBUFFER_SIZE_UART3-1)];
      return rcv_data;
    }
  }
  return (int16_t)-1;
}

void UART_Clear_Buffer(UART_HandleTypeDef *huart, uint16_t size)
{
  uint8_t data_size;

  if(huart->Instance==USART2) {
    HAL_NVIC_DisableIRQ(USART2_IRQn);
    data_size=UART_Available(&huart2);

    if(size==0) {       //All Clear
      uart_rx_uart2.head=uart_rx_uart2.tail;
    }
    else {
      if(data_size < size)    size = data_size;
      uart_rx_uart2.head += size;
      uart_rx_uart2.head &= MAX_RXBUFFER_SIZE_UART2-1;
    }
    HAL_NVIC_EnableIRQ(USART2_IRQn);
  }
  if(huart->Instance==USART3) {
    HAL_NVIC_DisableIRQ(USART3_IRQn);
    data_size=UART_Available(&huart3);

    if(size==0) {       //All Clear
      uart_rx_uart3.head=uart_rx_uart3.tail;
    }
    else {
      if(data_size < size)    size = data_size;
      uart_rx_uart3.head += size;
      uart_rx_uart3.head &= MAX_RXBUFFER_SIZE_UART3-1;
    }
    HAL_NVIC_EnableIRQ(USART3_IRQn);
  }
}

#include  <stdlib.h>
char *Float2String(float f, int point)
{
  static char str[20];
  static char format[2][9] = {"%d.%0?d", "-%d.%0?d"};
  long num, divider = 10;
  uint8_t flag;

  if(f<0)                   flag = 1, f=-f;
  else                      flag = 0;

  if(point>9)               point = 9;
  else if(point<1)          point = 1;
  format[flag][5+flag] = '0'+point;           //Position of '?'

  for(; point>1; point--)   divider *= 10;    //divider = pow(10, point);
  num = (long)(f*divider);
  sprintf(str, format[flag], num/divider, num%divider);
  return str;
}

void BLE_Init(void)
{
#if   HW_VER >= 3
  pinMode(BLE_RESET_PIN, OUTPUT);
  pinMode(BLE_CONN_PIN, INPUT);
  BLE_Wakeup();
#endif
}

void BLE_Sleep(void)
{
  //LOW to /RESET(#11) for BLE_Module DX-BT19-S
#if   HW_VER >= 3
  digitalWrite(BLE_RESET_PIN, LOW);
  Delay_msec(50);
#endif
}

void BLE_Wakeup(void)
{
  //HIGH to /RESET(#11) for BLE_Module DX-BT19-S
#if   HW_VER >= 3
  digitalWrite(BLE_RESET_PIN, HIGH);
  Delay_msec(200);
#endif
}

void BLE_Reset(void)
{
  BLE_Sleep();
  BLE_Wakeup();
}
// (25.05.05)
int BLE_CONN_Status, BLE_DISCON_Task;
void Check_BLE_Status(void){
  int old = BLE_CONN_Status;
  BLE_CONN_Status =! digitalRead(BLE_CONN_PIN);
//  0 : Not connected, 1 : Connected
  if(old - BLE_CONN_Status == 1) {  // 연결이 해제된 경우
    BLE_DISCON_Task = 1;
    WP_LEDCtrl.BLEDisconnection = 3;
    WP_Weight.Ctrl.OnOffStatus[L] = OFF;
    WP_Weight.Ctrl.OnOffStatus[R] = OFF;
  }
  if(old == 0 && BLE_CONN_Status == 1) { // 연결이 성립된 경우
    WP_LEDCtrl.BLEDisconnection = -3;  // 연결 상태 LED 제어
    // 필요시 연결 시 초기화 작업 수행
  }

  if(BLE_DISCON_Task == 1) {        //
    Initialize_Weight();
    if(WP_Weight.Ctrl.OnOffScale[L] < 0.1f && WP_Weight.Ctrl.OnOffScale[R] < 0.1f ) {
      WP_Gym.WeightSet[L] = 0.0f;
      WP_Gym.WeightSet[R] = 0.0f;
      BLE_DISCON_Task = 0;
    }
  }
}

uint8_t UART_BLE_Rename(UART_HandleTypeDef *huart, char name[])
{
  BLE_Reset();                    //must RESET BLE_MODULE
  UART_Clear(huart);

  UART_printf(huart, "AT\r\n");
  Delay_msec(100);
  if((UART_Available(huart)<2) || !(UART_Getc_NoClear(huart,0)=='O' && UART_Getc_NoClear(huart,1)=='K')) {
    UART_Clear(huart);
    UART_printf(huart, "\r\nBLE Rename ERROR\r\n");
    BLE_Reset();                    //must RESET BLE_MODULE
    return ERROR;
  }
  UART_Clear(huart);

  char ble_mac[5];
                                          //          0123456789012345678901234 5 6
  UART_printf(huart, "AT+LADDR\r\n");     //Return : "+LADDR=00:15:8C:96:04:FE\r\n"
  Delay_msec(100);

  if(UART_Available(huart)<26) {
    UART_Clear(huart);
    UART_printf(huart, "\r\nBLE Rename ERROR\r\n");
    BLE_Reset();                    //must RESET BLE_MODULE
    return ERROR;
  }
  if(UART_Getc_NoClear(huart,0)=='+' && UART_Getc_NoClear(huart,1)=='L' && UART_Getc_NoClear(huart,2)=='A'
  && UART_Getc_NoClear(huart,3)=='D' && UART_Getc_NoClear(huart,4)=='D' && UART_Getc_NoClear(huart,5)=='R' && UART_Getc_NoClear(huart,6)=='=') {
    ble_mac[0]=UART_Getc_NoClear(huart,19);
    ble_mac[1]=UART_Getc_NoClear(huart,20);
    ble_mac[2]=UART_Getc_NoClear(huart,22);
    ble_mac[3]=UART_Getc_NoClear(huart,23);
    ble_mac[4]=0;
  }
  else {
    UART_Clear(huart);
    UART_printf(huart, "\r\nBLE Rename ERROR\r\n");
    BLE_Reset();                    //must RESET BLE_MODULE
    return ERROR;
  }
  UART_Clear(huart);
/*
#define   MAX_PACKET      26
  char ble_name[MAX_PACKET];
  uint8_t ble_name_size;
                                          //          01234567890 1 2
  UART_printf(huart, "AT+NAME\r\n");      //Return : "+NAME=BT05\r\n"
  Delay_msec(100);

  if(UART_Available(huart)<10) {
    UART_Clear(huart);
    UART_printf(huart, "\r\nBLE Rename ERROR\r\n");
    BLE_Reset();                    //must RESET BLE_MODULE
    return ERROR;
  }
  if(UART_Getc_NoClear(huart,0)=='+' && UART_Getc_NoClear(huart,1)=='N' && UART_Getc_NoClear(huart,2)=='A'
  && UART_Getc_NoClear(huart,3)=='M' && UART_Getc_NoClear(huart,4)=='E' && UART_Getc_NoClear(huart,5)=='=') {
    int i;
    for(i=0;i<MAX_PACKET;i++) {
      uint16_t ch = UART_Getc_NoClear(huart, 6+i);
      if(ch==-1 || ch=='\r' || ch=='\n') {
        ble_name[i]=0;
        break;
      }
      else {
        ble_name[i]=(char)ch;
      }
    }
    if(i==MAX_PACKET)
    ble_name_size = i;
  }
  else {
    UART_Clear(huart);
    UART_printf(huart, "\r\nBLE Rename ERROR\r\n");
    BLE_Reset();                    //must RESET BLE_MODULE
    return ERROR;
  }
*/
  UART_printf(huart, "AT+NAME%s_%s\r\n", name, ble_mac);
  UART_Clear(huart);
  Delay_msec(100);

  BLE_Reset();                    //must RESET BLE_MODULE
  UART_printf(huart, "\r\nBLE Rename OK\r\n");
  BLE_Init();
  return SUCCESS;
}
/* USER CODE END 1 */