//***************************************************************************** // // uartstdio.c - Utility driver to provide simple UART console functions. // //***************************************************************************** /* * Copyright (C) 2009-2015 Texas Instruments Incorporated - www.ti.com * * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the * distribution. * * Neither the name of Texas Instruments Incorporated nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ #include #include #include #include "sci.h" #include "uartstdio.h" //***************************************************************************** // // A mapping from an integer between 0 and 15 to its ASCII character // equivalent. // //***************************************************************************** static const char * const g_pcHex = "0123456789abcdef"; //***************************************************************************** // //! Writes a string of characters to the UART output. //! //! \param pcBuf points to a buffer containing the string to transmit. //! \param ui32Len is the length of the string to transmit. //! //! This function will transmit the string to the UART output. The number of //! characters transmitted is determined by the \e ui32Len parameter. This //! function does no interpretation or translation of any characters. Since //! the output is sent to a UART, any LF (/n) characters encountered will be //! replaced with a CRLF pair. //! //! Besides using the \e ui32Len parameter to stop transmitting the string, if //! a null character (0) is encountered, then no more characters will be //! transmitted and the function will return. //! //! In non-buffered mode, this function is blocking and will not return until //! all the characters have been written to the output FIFO. In buffered mode, //! the characters are written to the UART transmit buffer and the call returns //! immediately. If insufficient space remains in the transmit buffer, //! additional characters are discarded. //! //! \return Returns the count of characters written. // //***************************************************************************** int UARTwrite(const char *pcBuf, unsigned int ui32Len) { unsigned int uIdx; // // Send the characters // for(uIdx = 0; uIdx < ui32Len; uIdx++) { // // If the character to the UART is \n, then add a \r before it so that // \n is translated to \n\r in the output. // if(pcBuf[uIdx] == '\n') { sciSendByte(scilinREG, '\r'); } // // Send the character to the UART output. // sciSendByte(scilinREG, pcBuf[uIdx]); } // // Return the number of characters written. // return(uIdx); } //***************************************************************************** // //! A simple UART based get string function, with some line processing. //! //! \param pcBuf points to a buffer for the incoming string from the UART. //! \param ui32Len is the length of the buffer for storage of the string, //! including the trailing 0. //! //! This function will receive a string from the UART input and store the //! characters in the buffer pointed to by \e pcBuf. The characters will //! continue to be stored until a termination character is received. The //! termination characters are CR, LF, or ESC. A CRLF pair is treated as a //! single termination character. The termination characters are not stored in //! the string. The string will be terminated with a 0 and the function will //! return. //! //! In both buffered and unbuffered modes, this function will block until //! a termination character is received. If non-blocking operation is required //! in buffered mode, a call to UARTPeek() may be made to determine whether //! a termination character already exists in the receive buffer prior to //! calling UARTgets(). //! //! Since the string will be null terminated, the user must ensure that the //! buffer is sized to allow for the additional null character. //! //! \return Returns the count of characters that were stored, not including //! the trailing 0. // //***************************************************************************** int UARTgets( char *pcBuf, unsigned int ui32Len) { unsigned int ui32Count = 0; int8_t cChar; static int8_t bLastWasCR = 0; // // Adjust the length back by 1 to leave space for the trailing // null terminator. // ui32Len--; // // Process characters until a newline is received. // while(1) { // // Read the next character from the console. // cChar = sciReceiveByte(scilinREG); // // See if the backspace key was pressed. // if(cChar == '\b') { // // If there are any characters already in the buffer, then delete // the last. // if(ui32Count) { // // Rub out the previous character. // UARTwrite("\b \b", 3); // // Decrement the number of characters in the buffer. // ui32Count--; } // // Skip ahead to read the next character. // continue; } // // If this character is LF and last was CR, then just gobble up the // character because the EOL processing was taken care of with the CR. // if((cChar == '\n') && bLastWasCR) { bLastWasCR = 0; continue; } // // See if a newline or escape character was received. // if((cChar == '\r') || (cChar == '\n') || (cChar == 0x1b)) { // // If the character is a CR, then it may be followed by a LF which // should be paired with the CR. So remember that a CR was // received. // if(cChar == '\r') { bLastWasCR = 1; } // // Stop processing the input and end the line. // break; } // // Process the received character as long as we are not at the end of // the buffer. If the end of the buffer has been reached then all // additional characters are ignored until a newline is received. // if(ui32Count < ui32Len) { // // Store the character in the caller supplied buffer. // pcBuf[ui32Count] = cChar; // // Increment the count of characters received. // ui32Count++; // // Reflect the character back to the user. // sciSendByte(scilinREG, cChar); } } // // Add a null termination to the string. // pcBuf[ui32Count] = 0; // // Send a CRLF pair to the terminal to end the line. // UARTwrite("\r\n", 2); // // Return the count of int8_ts in the buffer, not counting the trailing 0. // return(ui32Count); } //***************************************************************************** // //! Read a single character from the UART, blocking if necessary. //! //! This function will receive a single character from the UART and store it at //! the supplied address. //! //! In both buffered and unbuffered modes, this function will block until a //! character is received. If non-blocking operation is required in buffered //! mode, a call to UARTRxAvail() may be made to determine whether any //! characters are currently available for reading. //! //! \return Returns the character read. // //***************************************************************************** unsigned char UARTgetc(void) { // // Block until a character is received by the UART then return it to // the caller. // return(sciReceiveByte(scilinREG)); } //***************************************************************************** // //! A simple UART based vprintf function supporting \%c, \%d, \%p, \%s, \%u, //! \%x, and \%X. //! //! \param pcString is the format string. //! \param vaArgP is a variable argument list pointer whose content will depend //! upon the format string passed in \e pcString. //! //! This function is very similar to the C library vprintf() function. //! All of its output will be sent to the UART. Only the following formatting //! characters are supported: //! //! - \%c to print a character //! - \%d or \%i to print a decimal value //! - \%s to print a string //! - \%u to print an unsigned decimal value //! - \%x to print a hexadecimal value using lower case letters //! - \%X to print a hexadecimal value using lower case letters (not upper case //! letters as would typically be used) //! - \%p to print a pointer as a hexadecimal value //! - \%\% to print out a \% character //! //! For \%s, \%d, \%i, \%u, \%p, \%x, and \%X, an optional number may reside //! between the \% and the format character, which specifies the minimum number //! of characters to use for that value; if preceded by a 0 then the extra //! characters will be filled with zeros instead of spaces. For example, //! ``\%8d'' will use eight characters to print the decimal value with spaces //! added to reach eight; ``\%08d'' will use eight characters as well but will //! add zeroes instead of spaces. //! //! The type of the arguments in the variable arguments list must match the //! requirements of the format string. For example, if an integer was passed //! where a string was expected, an error of some kind will most likely occur. //! //! \return None. // //***************************************************************************** void UARTvprintf(const char *pcString, va_list vaArgP) { unsigned int ui32Idx, ui32Value, ui32Pos, ui32Count, ui32Base, ui32Neg; char *pcStr, pcBuf[16], cFill; // // Loop while there are more characters in the string. // while(*pcString) { // // Find the first non-% character, or the end of the string. // for(ui32Idx = 0; (pcString[ui32Idx] != '%') && (pcString[ui32Idx] != '\0'); ui32Idx++) { } // // Write this portion of the string. // UARTwrite(pcString, ui32Idx); // // Skip the portion of the string that was written. // pcString += ui32Idx; // // See if the next character is a %. // if(*pcString == '%') { // // Skip the %. // pcString++; // // Set the digit count to zero, and the fill character to space // (in other words, to the defaults). // ui32Count = 0; cFill = ' '; // // It may be necessary to get back here to process more characters. // Goto's aren't pretty, but effective. I feel extremely dirty for // using not one but two of the beasts. // again: // // Determine how to handle the next character. // switch(*pcString++) { // // Handle the digit characters. // case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { // // If this is a zero, and it is the first digit, then the // fill character is a zero instead of a space. // if((pcString[-1] == '0') && (ui32Count == 0)) { cFill = '0'; } // // Update the digit count. // ui32Count *= 10; ui32Count += pcString[-1] - '0'; // // Get the next character. // goto again; } // // Handle the %c command. // case 'c': { // // Get the value from the varargs. // ui32Value = va_arg(vaArgP, unsigned int); // // Print out the character. // UARTwrite((char *)&ui32Value, 1); // // This command has been handled. // break; } // // Handle the %d and %i commands. // case 'd': case 'i': { // // Get the value from the varargs. // ui32Value = va_arg(vaArgP, unsigned int); // // Reset the buffer position. // ui32Pos = 0; // // If the value is negative, make it positive and indicate // that a minus sign is needed. // if((int32_t)ui32Value < 0) { // // Make the value positive. // ui32Value = -(int32_t)ui32Value; // // Indicate that the value is negative. // ui32Neg = 1; } else { // // Indicate that the value is positive so that a minus // sign isn't inserted. // ui32Neg = 0; } // // Set the base to 10. // ui32Base = 10; // // Convert the value to ASCII. // goto convert; } // // Handle the %s command. // case 's': { // // Get the string pointer from the varargs. // pcStr = va_arg(vaArgP, char *); // // Determine the length of the string. // for(ui32Idx = 0; pcStr[ui32Idx] != '\0'; ui32Idx++) { } // // Write the string. // UARTwrite(pcStr, ui32Idx); // // Write any required padding spaces // if(ui32Count > ui32Idx) { ui32Count -= ui32Idx; while(ui32Count--) { UARTwrite(" ", 1); } } // // This command has been handled. // break; } // // Handle the %u command. // case 'u': { // // Get the value from the varargs. // ui32Value = va_arg(vaArgP, unsigned int); // // Reset the buffer position. // ui32Pos = 0; // // Set the base to 10. // ui32Base = 10; // // Indicate that the value is positive so that a minus sign // isn't inserted. // ui32Neg = 0; // // Convert the value to ASCII. // goto convert; } // // Handle the %x and %X commands. Note that they are treated // identically; in other words, %X will use lower case letters // for a-f instead of the upper case letters it should use. We // also alias %p to %x. // case 'x': case 'X': case 'p': { // // Get the value from the varargs. // ui32Value = va_arg(vaArgP, unsigned int); // // Reset the buffer position. // ui32Pos = 0; // // Set the base to 16. // ui32Base = 16; // // Indicate that the value is positive so that a minus sign // isn't inserted. // ui32Neg = 0; // // Determine the number of digits in the string version of // the value. // convert: for(ui32Idx = 1; (((ui32Idx * ui32Base) <= ui32Value) && (((ui32Idx * ui32Base) / ui32Base) == ui32Idx)); ui32Idx *= ui32Base, ui32Count--) { } // // If the value is negative, reduce the count of padding // characters needed. // if(ui32Neg) { ui32Count--; } // // If the value is negative and the value is padded with // zeros, then place the minus sign before the padding. // if(ui32Neg && (cFill == '0')) { // // Place the minus sign in the output buffer. // pcBuf[ui32Pos++] = '-'; // // The minus sign has been placed, so turn off the // negative flag. // ui32Neg = 0; } // // Provide additional padding at the beginning of the // string conversion if needed. // if((ui32Count > 1) && (ui32Count < 16)) { for(ui32Count--; ui32Count; ui32Count--) { pcBuf[ui32Pos++] = cFill; } } // // If the value is negative, then place the minus sign // before the number. // if(ui32Neg) { // // Place the minus sign in the output buffer. // pcBuf[ui32Pos++] = '-'; } // // Convert the value into a string. // for(; ui32Idx; ui32Idx /= ui32Base) { pcBuf[ui32Pos++] = g_pcHex[(ui32Value / ui32Idx) % ui32Base]; } // // Write the string. // UARTwrite(pcBuf, ui32Pos); // // This command has been handled. // break; } // // Handle the %% command. // case '%': { // // Simply write a single %. // UARTwrite(pcString - 1, 1); // // This command has been handled. // break; } // // Handle all other commands. // default: { // // Indicate an error. // UARTwrite("ERROR", 5); // // This command has been handled. // break; } } } } } //***************************************************************************** // //! A simple UART based printf function supporting \%c, \%d, \%p, \%s, \%u, //! \%x, and \%X. //! //! \param pcString is the format string. //! \param ... are the optional arguments, which depend on the contents of the //! format string. //! //! This function is very similar to the C library fprintf() function. //! All of its output will be sent to the UART. Only the following formatting //! characters are supported: //! //! - \%c to print a character //! - \%d or \%i to print a decimal value //! - \%s to print a string //! - \%u to print an unsigned decimal value //! - \%x to print a hexadecimal value using lower case letters //! - \%X to print a hexadecimal value using lower case letters (not upper case //! letters as would typically be used) //! - \%p to print a pointer as a hexadecimal value //! - \%\% to print out a \% character //! //! For \%s, \%d, \%i, \%u, \%p, \%x, and \%X, an optional number may reside //! between the \% and the format character, which specifies the minimum number //! of characters to use for that value; if preceded by a 0 then the extra //! characters will be filled with zeros instead of spaces. For example, //! ``\%8d'' will use eight characters to print the decimal value with spaces //! added to reach eight; ``\%08d'' will use eight characters as well but will //! add zeroes instead of spaces. //! //! The type of the arguments after \e pcString must match the requirements of //! the format string. For example, if an integer was passed where a string //! was expected, an error of some kind will most likely occur. //! //! \return None. // //***************************************************************************** void UARTprintf(const char *pcString, ...) { va_list vaArgP; // // Start the varargs processing. // va_start(vaArgP, pcString); UARTvprintf(pcString, vaArgP); // // We're finished with the varargs now. // va_end(vaArgP); }