uart1.c

MSP430开发过程中

//filename: uart1.c
#include "uart.h"
#include  "msp430x26x.h"
//写一个数组到串口上   接收端必须以16进制显示。
uint16 halUartWrite(const uint8* buf, uint16 length)
{
    uint16 i;
    for(i = 0; i < length; i++)
    {
        while(!(IFG2 & UCA0TXIFG));    // Wait for TX buffer ready to receive new byte  也可以单独写一个数到串口上
        UCA0TXBUF = buf[i];            // Output character
    }
    return (i+1);
}


//写字符串到串口   
/***********************************************************************************
* @fn      printStr
*
* @brief   Print a zero-terminated string on the console
*
* @param   sz - string to send to the console
*
* @return  none
*/
void printStr(char* sz)
{
    char lineFeed = '\r';  
    halUartWrite((uint8*)sz, (uint16) strlen(sz));
    // if last character is newline, add carriage return
    if(*(sz+(strlen(sz)-1)) == '\n')
        halUartWrite((uint8*)&lineFeed,1);  
}
//写一个字符
void printChar(char c)
{ 
    halUartWrite((uint8*)&c, 1);
}

//写一个字符串和长度
void printStrW(char *sz, uint8 nBytes)
{
    printStr((char *)sz);
    if (strlen(sz)<nBytes) {
        nBytes-= strlen(sz);
        while(--nBytes>0)
            printChar('s');
    }
}
// 写一个16进制数据到串口
/***********************************************************************************
* @fn      printHex
*
* @brief   Print an integer as hexadecimal.
*
* @param   v - the value to be displayed
*          s - size (8,16,32) | bit 7 to omit 'h' at the end
*
* @return  none
*/
void printHex(uint32 v, uint8 s)
{
    char buf[16];
    uint8 w;
    
    w= (s&~NO_HEX_INDICATION)>>2;        // String length
    
    if (s&NO_HEX_INDICATION) {
        buf[w]= '\0';
    } else {
        buf[w]= 'h';       // HEX
        buf[w+1]= '\0';    // String terminator
    }
    
    // Convert number
    do {
        w--;
        buf[w]= "0123456789ABCDEF"[v&0xF];
        v>>= 4;
    } while(w>0);
    
    // Print
    printStr(buf);
}
//格式打印一个16进制数据      printKvpHex("Chip ID: ", chipId);
/***********************************************************************************
* @fn      printKvpHex
*
* @brief   Print a Key-Value pair hexadecimal
*
* @param   szKey - the value to be displayed
*          v - the value to be displayed
*
* @return  none
*/
void printKvpHex(char *szKey, uint16 v)
{
    printStrW(szKey, KVP_ALIGN);
    printStr(": ");
    printHex(v,16);
    printChar('\n');
    printChar('\r');
}

//打印一个十进制数据
/***********************************************************************************
* @fn      printInt
*
* @brief   Print a 32-bit integer as decimal.
*
* @param   v - the value to be displayed
*
* @return  none
*/
//写一个整型数据
void printInt(uint32 v)
{
    uint32 iDiv;
    BOOL bLeadingZero;
    
    // Initialise
    iDiv= 1000000000;
    bLeadingZero= TRUE;
    
    // For each digit
    while (iDiv>0) {
        uint8 vDigit;
        
        // Current digit
        vDigit= (v / iDiv);
        
        // First digit to be printed
        if (vDigit>0) {	
            bLeadingZero= FALSE;
        }
        
        if (!bLeadingZero) {
            printChar( '0' + vDigit );
        }
        
        // Next digit
        v= v % iDiv;
        iDiv= iDiv/10;
    }
    
    // Special case zero
    if (bLeadingZero) {
        printChar('0');
    }  
}
//打印格式 十进制数据
/***********************************************************************************
* @fn      printKvpInt        printKvpInt("Chip ID: ", chipId);
*
* @brief   Print a Key-Value pair hexadeciaml.
* 
* @param   szKey - the value to be displayed
*
*          v - the value to be displayed
*
* @return  none
*/
void printKvpInt(char *szKey, uint32 v)
{
    printStrW(szKey, 10);//printStrW(szKey, KVP_ALIGN);
    printStr(": ");
    printInt(v);
    printChar('\n');
    printChar('\r');
}

/***********************************************************************************
* @fn          convInt32ToText
*
* @brief       Converts 32 bit int to text
*
* @param       int32 value
*          
* @return      char* - pointer to text buffer which is a file scope allocated array
*/
char* convInt32ToText(int32 value) {
    char *pLast = pValueToTextBuffer;
    char *pFirst;
    char last;
    
    // Record the sign of the value
    uint8 negative = (value < 0);
    value = ABS(value);
    
    // Print the value in the reverse order
    do {
        *(pLast++) = '0' + (value % 10);
        value /= 10;
    } while (value);
    
    // Add the '-' when the number is negative, and terminate the string
    if (negative) *(pLast++) = '-';
    *(pLast--) = 0x00;
    
    // Now reverse the string
    pFirst = pValueToTextBuffer;
    while (pLast > pFirst) {
        last = *pLast;
        *(pLast--) = *pFirst;
        *(pFirst++) = last;
    }
    
    return pValueToTextBuffer;
} 


/***********************************************************************************
* @fn          min
*
* @brief       Return minimum of two values
*
* @param       uint8 v1 - value 1
*              uint8 v2 - value 2
*
* @return      uint8 - minimum of two values
*/
uint8 min(uint8 v1, uint8 v2)
{
    if(v1 < v2)
        return v1;
    else return v2;
}