//***************************************************************************** // //! 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(SCI_REG, '\r'); } // // Send the character to the UART output. // sciSendByte(SCI_REG, pcBuf[uIdx]); } // // Return the number of characters written. // return(uIdx); }
/* USER CODE BEGIN (4) */ void sciDisplayText(sciBASE_t *sci, uint8 *text,uint32 length) { while(length--) { while ((UART->FLR & 0x4) == 4); /* wait until busy */ sciSendByte(UART,*text++); /* send out text */ }; }
//***************************************************************************** // //! 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(SCI_REG); // // 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(SCI_REG, 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); }