uartutil.c

基于MMA7260QR2的跌落检查程序

* Callback function for the transmission interruption in the Uart1.
*******************************************************************************/
void UartEventWrite2(UartWriteCallbackArgs_t* args)
{
}

/*******************************************************************************  
* HexToAscii
*
* This function converts an hexadecimal value in ascii code.
*******************************************************************************/
static uint8_t HexToAscii(uint8_t u8Hex)
{
  u8Hex &= 0x0F;
  return u8Hex + ((u8Hex <= 9) ? '0' : ('A'-10));
}

/*******************************************************************************  
* Uart_putchar
*
* This function print a byte in the serial interface
*******************************************************************************/
void Uart_putchar(uint8_t u8Char)
{
  UartWriteData(gUart_PortDefault_d,&u8Char,1);
}


/*******************************************************************************  
* Uart_Print
*
* This function transmit a string to the initializated Uart. 
*******************************************************************************/
void Uart_Print(uint8_t* pString)
{
  uint8_t WriteBuffer[1];
  uint8_t length = 0;
  uint16_t u8Timeout;
  while(pString[length] != '\0'){
    WriteBuffer[0] = pString[length];
    length++;
    u8Timeout = 0;
    while((UartWriteData(gUart_PortDefault_d,WriteBuffer,1) != gUartErrNoError_c) && (u8Timeout < gUartTimeout_d))
    {
      u8Timeout ++;
    }
  }
}

/*******************************************************************************  
* Uart_getchar
*
* Waits until a character is received in the Uart. 
*******************************************************************************/
char Uart_getchar(uint8_t * u8Char)
{
  while(FALSE == gu8SCIDataFlag){
    UartReadData(gUart_PortDefault_d,u8Char,1,TRUE);
  }
  gu8SCIDataFlag = FALSE;
  return (char)u8Char[0];
}

/*******************************************************************************  
* Uart_Tx
*
* Transmits a buffer to the UART. 
*******************************************************************************/
void Uart_Tx(const uint8_t * msg, uint8_t length)
{
  uint8_t WriteBuffer[1];
  uint32_t i;
  uint16_t u8Timeout;

  for(i=0;i<length;i++)
  {
    if(*msg == '\n' ){
      WriteBuffer[0] = '\r';
      u8Timeout = 0;
      while((UartWriteData(gUart_PortDefault_d,WriteBuffer,1) != gUartErrNoError_c) && (u8Timeout < gUartTimeout_d))
      {
        u8Timeout ++;
      }
    }
    WriteBuffer[0] = *msg;
    
    u8Timeout = 0;
    while((UartWriteData(gUart_PortDefault_d,WriteBuffer,1) != gUartErrNoError_c) && u8Timeout < gUartTimeout_d )
    {
      u8Timeout ++;
    }
   
    msg++;
  }
}

uint8_t Uart_Poll(uint8_t *pRxBuffer)
{
  UartReadData(gUart_PortDefault_d, pRxBuffer,1,TRUE);
  gu8SCIDataFlag = FALSE;
}


/*******************************************************************************  
* AsciitoHex
*
* This function converts an ascii code in a hexadecimal value.
*******************************************************************************/
uint8_t AsciitoHex(uint8_t u8Ascii)
{
  if ((u8Ascii > 47) && (u8Ascii <= 57)){
    return u8Ascii - '0';
  }
  else{ 
    if((u8Ascii > 64) && (u8Ascii <= 70))
    { 
      return (u8Ascii - 'A' + 10);
    }
    else if((u8Ascii > 96) && (u8Ascii <= 102))
    {
      return (u8Ascii - 'a' + 10);
    } 
  }
}

/*******************************************************************************  
* Uart_PrintHex
*
* This function transmit a hexadecimal value to the initializated Uart. 
*******************************************************************************/
void Uart_PrintHex(uint8_t *pu8Hex, uint8_t u8len, uint8_t u8flags)
{
  uint8_t hexString[3];
  if(! (u8flags & gPrtHexBigEndian_c))
    pu8Hex = pu8Hex + (u8len-1);
  
  while(u8len)
  {
    hexString[2] = '\0';
    hexString[1] = HexToAscii( *pu8Hex );
    hexString[0] = HexToAscii((*pu8Hex)>>4);
    
    Uart_Print((uint8_t*) hexString);
    
    if(u8flags & gPrtHexCommas_c)
      Uart_Print((uint8_t*)",");
    pu8Hex = pu8Hex + (u8flags & gPrtHexBigEndian_c ? 1 : -1);
    u8len--;
  }
  if(u8flags & gPrtHexNewLine_c)
    Uart_Print((uint8_t*)"\n");
}

/*******************************************************************************  
* Uart_PrintByteDec
*
* This function transmit a decimal value to the initializated Uart
*******************************************************************************/
void Uart_PrintByteDec(uint8_t u8Dec)
{
  uint8_t decString[3];
  uint8_t  tem;
  tem = u8Dec & 0x0F;
  decString[2] = '\0';
  decString[0]= tem/10;
  decString[1] = tem%10;

  tem = ((u8Dec>>4) & 0x0F);
  tem = tem * 16;
  
  if(decString[1] + (tem%10) >= 10){
    decString[0] = ( decString[0] + (tem/10) + 1 + '0');
    decString[1] = ( decString[1] + (tem%10) - 10 +'0');
  }
  else{
    decString[0] = ( decString[0] + (tem/10) + '0');
    decString[1] = ( decString[1] + (tem%10) + '0');
  }
  Uart_Print((uint8_t*) decString);
}

/*******************************************************************************  
* Uart_PrintShortDec
*
* This function transmit a decimal value to the initializated Uart
*******************************************************************************/
void Uart_PrintShortDec(uint16_t u16Dec)
{
  uint8_t decString[6];
  uint16_t  temp;

  decString[5] = '\0';
  temp = u16Dec;

  decString[4] = (temp%10) + '0';
  temp = temp/10;
  decString[3] = (temp%10) + '0';
  temp = temp/10;
  decString[2] = (temp%10) + '0';
  temp = temp/10;
  decString[1] = (temp%10) + '0';
  temp = temp/10;

  decString[0] = temp + '0';

  Uart_Print((uint8_t*) decString);
}

/*******************************************************************************  
* mem_cmp 
*
* This function compare two strings, return FALSE when these are diferents or 
* TRUE when are equals.
*******************************************************************************/
bool_t mem_cmp(uint8_t * str1, uint8_t * str2, uint8_t sz)
{
  uint8_t i;
  for(i=0; i<sz; i++)
  {
    if( (str1[i]) != (str2[i]))
    {
      return FALSE;
    }
  }
  return TRUE;
}