text: /**
    ******************************************************************************
    * @file    STM32F4xx_IAP/src/common.c 
    * @author  MCD Application Team
    * @version V1.0.0
    * @date    10-October-2011
    * @brief   This file provides all the common functions.
    ******************************************************************************
    * @attention
    *
    * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
    * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    *
    * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
    ******************************************************************************
    */ 
  
  /** @addtogroup STM32F4xx_IAP
    * @{
    */
  
  /* Includes ------------------------------------------------------------------*/
  #include "common.h"
  
  /* Private typedef -----------------------------------------------------------*/
  /* Private define ------------------------------------------------------------*/
  /* Private macro -------------------------------------------------------------*/
  /* Private variables ---------------------------------------------------------*/
  /* Private function prototypes -----------------------------------------------*/
  /* Private functions ---------------------------------------------------------*/
  
  /**
    * @brief  Convert an Integer to a string
    * @param  str: The string
    * @param  intnum: The integer to be converted
    * @retval None
    */
  void Int2Str(uint8_t* str, int32_t intnum)
  {
    uint32_t i, Div = 1000000000, j = 0, Status = 0;
  
    for (i = 0; i < 10; i++)
    {
      str[j++] = (intnum / Div) + 48;
  
      intnum = intnum % Div;
      Div /= 10;
      if ((str[j-1] == '0') & (Status == 0))
      {
        j = 0;
      }
      else
      {
        Status++;
      }
    }
  }
  
  /**
    * @brief  Convert a string to an integer
    * @param  inputstr: The string to be converted
    * @param  intnum: The integer value
    * @retval 1: Correct
    *         0: Error
    */
  uint32_t Str2Int(uint8_t *inputstr, int32_t *intnum)
  {
    uint32_t i = 0, res = 0;
    uint32_t val = 0;
  
    if (inputstr[0] == '0' && (inputstr[1] == 'x' || inputstr[1] == 'X'))
    {
      if (inputstr[2] == '\0')
      {
        return 0;
      }
      for (i = 2; i < 11; i++)
      {
        if (inputstr[i] == '\0')
        {
          *intnum = val;
          /* return 1; */
          res = 1;
          break;
        }
        if (ISVALIDHEX(inputstr[i]))
        {
          val = (val << 4) + CONVERTHEX(inputstr[i]);
        }
        else
        {
          /* Return 0, Invalid input */
          res = 0;
          break;
        }
      }
      /* Over 8 digit hex --invalid */
      if (i >= 11)
      {
        res = 0;
      }
    }
    else /* max 10-digit decimal input */
    {
      for (i = 0;i < 11;i++)
      {
        if (inputstr[i] == '\0')
        {
          *intnum = val;
          /* return 1 */
          res = 1;
          break;
        }
        else if ((inputstr[i] == 'k' || inputstr[i] == 'K') && (i > 0))
        {
          val = val << 10;
          *intnum = val;
          res = 1;
          break;
        }
        else if ((inputstr[i] == 'm' || inputstr[i] == 'M') && (i > 0))
        {
          val = val << 20;
          *intnum = val;
          res = 1;
          break;
        }
        else if (ISVALIDDEC(inputstr[i]))
        {
          val = val * 10 + CONVERTDEC(inputstr[i]);
        }
        else
        {
          /* return 0, Invalid input */
          res = 0;
          break;
        }
      }
      /* Over 10 digit decimal --invalid */
      if (i >= 11)
      {
        res = 0;
      }
    }
  
    return res;
  }
  
  /**
    * @brief  Get an integer from the HyperTerminal
    * @param  num: The integer
    * @retval 1: Correct
    *         0: Error
    */
  uint32_t GetIntegerInput(int32_t * num)
  {
    uint8_t inputstr[16];
  
    while (1)
    {
      GetInputString(inputstr);
      if (inputstr[0] == '\0') continue;
      if ((inputstr[0] == 'a' || inputstr[0] == 'A') && inputstr[1] == '\0')
      {
        SerialPutString("User Cancelled \r\n");
        return 0;
      }
  
      if (Str2Int(inputstr, num) == 0)
      {
        SerialPutString("Error, Input again: \r\n");
      }
      else
      {
        return 1;
      }
    }
  }
  
  /**
    * @brief  Test to see if a key has been pressed on the HyperTerminal
    * @param  key: The key pressed
    * @retval 1: Correct
    *         0: Error
    */
  uint32_t SerialKeyPressed(uint8_t *key)
  {
  
    if ( USART_GetFlagStatus(EVAL_COM1, USART_FLAG_RXNE) != RESET)
    {
      *key = (uint8_t)EVAL_COM1->DR;
      return 1;
    }
    else
    {
      return 0;
    }
  }
  
  /**
    * @brief  Get a key from the HyperTerminal
    * @param  None
    * @retval The Key Pressed
    */
  uint8_t GetKey(void)
  {
    uint8_t key = 0;
  
    /* Waiting for user input */
    while (1)
    {
      if (SerialKeyPressed((uint8_t*)&key)) break;
    }
    return key;
  
  }
  
  /**
    * @brief  Print a character on the HyperTerminal
    * @param  c: The character to be printed
    * @retval None
    */
  void SerialPutChar(uint8_t c)
  {
    USART_SendData(EVAL_COM1, c);
    while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TXE) == RESET)
    {
    }
  }
  
  /**
    * @brief  Print a string on the HyperTerminal
    * @param  s: The string to be printed
    * @retval None
    */
  void Serial_PutString(uint8_t *s)
  {
    while (*s != '\0')
    {
      SerialPutChar(*s);
      s++;
    }
  }
  
  /**
    * @brief  Get Input string from the HyperTerminal
    * @param  buffP: The input string
    * @retval None
    */
  void GetInputString (uint8_t * buffP)
  {
    uint32_t bytes_read = 0;
    uint8_t c = 0;
    do
    {
      c = GetKey();
      if (c == '\r')
        break;
      if (c == '\b') /* Backspace */
      {
        if (bytes_read > 0)
        {
          SerialPutString("\b \b");
          bytes_read --;
        }
        continue;
      }
      if (bytes_read >= CMD_STRING_SIZE )
      {
        SerialPutString("Command string size overflow\r\n");
        bytes_read = 0;
        continue;
      }
      if (c >= 0x20 && c <= 0x7E)
      {
        buffP[bytes_read++] = c;
        SerialPutChar(c);
      }
    }
    while (1);
    SerialPutString(("\n\r"));
    buffP[bytes_read] = '\0';
  }
  
  /**
    * @}
    */
  
  /*******************(C)COPYRIGHT 2011 STMicroelectronics *****END OF FILE******/
  