i am a newbie to TM4C123G
could anyone please guide me to connect the launchpad to the computer via RS232?
should i use the RXD TXD pins on the board or it can be done through the power pin?
following is my code:
// UARTTestMain.c
// Runs on LM4F120/TM4C123
// Used to test the UART.c driver
// Daniel Valvano
// May 30, 2014
/* This example accompanies the book
"Embedded Systems: Real Time Interfacing to Arm Cortex M Microcontrollers",
ISBN: 978-1463590154, Jonathan Valvano, copyright (c) 2014
Copyright 2014 by Jonathan W. Valvano, valvano@mail.utexas.edu
You may use, edit, run or distribute this file
as long as the above copyright notice remains
THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED
OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
VALVANO SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL,
OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
For more information about my classes, my research, and my books, see
http://users.ece.utexas.edu/~valvano/
*/
// U0Rx (VCP receive) connected to PA0
// U0Tx (VCP transmit) connected to PA1
#include <inc/tm4c123gh6pm.h>
#include <stdint.h>
#include "UART.h"
#define UART_FR_TXFF 0x00000020 // UART Transmit FIFO Full
#define UART_FR_RXFE 0x00000010 // UART Receive FIFO Empty
#define UART_LCRH_WLEN_8 0x00000060 // 8 bit word length
#define UART_LCRH_FEN 0x00000010 // UART Enable FIFOs
#define UART_CTL_UARTEN 0x00000001 // UART Enable
//------------UART_Init------------
// Initialize the UART for 115,200 baud rate (assuming 50 MHz UART clock),
// 8 bit word length, no parity bits, one stop bit, FIFOs enabled
// Input: none
// Output: none
void UART_Init(void){
SYSCTL_RCGCUART_R |= 0x01; // activate UART0
SYSCTL_RCGCGPIO_R |= 0x01; // activate port A
while((SYSCTL_PRGPIO_R&0x01) == 0);
UART0_CTL_R &= ~UART_CTL_UARTEN; // disable UART
UART0_IBRD_R = 27; // IBRD = int(50,000,000 / (16 * 115,200)) = int(27.1267)
UART0_FBRD_R = 8; // FBRD = int(0.1267 * 64 + 0.5) = 8
// 8 bit word length (no parity bits, one stop bit, FIFOs)
UART0_LCRH_R = (UART_LCRH_WLEN_8|UART_LCRH_FEN);
UART0_CTL_R |= UART_CTL_UARTEN; // enable UART
GPIO_PORTA_AFSEL_R |= 0x03; // enable alt funct on PA1-0
GPIO_PORTA_DEN_R |= 0x03; // enable digital I/O on PA1-0
// configure PA1-0 as UART
GPIO_PORTA_PCTL_R = (GPIO_PORTA_PCTL_R&0xFFFFFF00)+0x00000011;
GPIO_PORTA_AMSEL_R &= ~0x03; // disable analog functionality on PA
}
//------------UART_InChar------------
// Wait for new serial port input
// Input: none
// Output: ASCII code for key typed
char UART_InChar(void){
while((UART0_FR_R&UART_FR_RXFE) != 0);
return((char)(UART0_DR_R&0xFF));
}
//------------UART_OutChar------------
// Output 8-bit to serial port
// Input: letter is an 8-bit ASCII character to be transferred
// Output: none
void UART_OutChar(char data){
while((UART0_FR_R&UART_FR_TXFF) != 0);
UART0_DR_R = data;
}
//------------UART_OutString------------
// Output String (NULL termination)
// Input: pointer to a NULL-terminated string to be transferred
// Output: none
void UART_OutString(char *pt){
while(*pt){
UART_OutChar(*pt);
pt++;
}
}
//------------UART_InUDec------------
// InUDec accepts ASCII input in unsigned decimal format
// and converts to a 32-bit unsigned number
// valid range is 0 to 4294967295 (2^32-1)
// Input: none
// Output: 32-bit unsigned number
// If you enter a number above 4294967295, it will return an incorrect value
// Backspace will remove last digit typed
uint32_t UART_InUDec(void){
uint32_t number=0, length=0;
char character;
character = UART_InChar();
while(character != CR){ // accepts until <enter> is typed
// The next line checks that the input is a digit, 0-9.
// If the character is not 0-9, it is ignored and not echoed
if((character>='0') && (character<='9')) {
number = 10*number+(character-'0'); // this line overflows if above 4294967295
length++;
UART_OutChar(character);
}
// If the input is a backspace, then the return number is
// changed and a backspace is outputted to the screen
else if((character==BS) && length){
number /= 10;
length--;
UART_OutChar(character);
}
character = UART_InChar();
}
return number;
}
//-----------------------UART_OutUDec-----------------------
// Output a 32-bit number in unsigned decimal format
// Input: 32-bit number to be transferred
// Output: none
// Variable format 1-10 digits with no space before or after
void UART_OutUDec(uint32_t n){
// This function uses recursion to convert decimal number
// of unspecified length as an ASCII string
if(n >= 10){
UART_OutUDec(n/10);
n = n%10;
}
UART_OutChar(n+'0'); /* n is between 0 and 9 */
}
//---------------------UART_InUHex----------------------------------------
// Accepts ASCII input in unsigned hexadecimal (base 16) format
// Input: none
// Output: 32-bit unsigned number
// No '$' or '0x' need be entered, just the 1 to 8 hex digits
// It will convert lower case a-f to uppercase A-F
// and converts to a 16 bit unsigned number
// value range is 0 to FFFFFFFF
// If you enter a number above FFFFFFFF, it will return an incorrect value
// Backspace will remove last digit typed
uint32_t UART_InUHex(void){
uint32_t number=0, digit, length=0;
char character;
character = UART_InChar();
while(character != CR){
digit = 0x10; // assume bad
if((character>='0') && (character<='9')){
digit = character-'0';
}
else if((character>='A') && (character<='F')){
digit = (character-'A')+0xA;
}
else if((character>='a') && (character<='f')){
digit = (character-'a')+0xA;
}
// If the character is not 0-9 or A-F, it is ignored and not echoed
if(digit <= 0xF){
number = number*0x10+digit;
length++;
UART_OutChar(character);
}
// Backspace outputted and return value changed if a backspace is inputted
else if((character==BS) && length){
number /= 0x10;
length--;
UART_OutChar(character);
}
character = UART_InChar();
}
return number;
}
//--------------------------UART_OutUHex----------------------------
// Output a 32-bit number in unsigned hexadecimal format
// Input: 32-bit number to be transferred
// Output: none
// Variable format 1 to 8 digits with no space before or after
void UART_OutUHex(uint32_t number){
// This function uses recursion to convert the number of
// unspecified length as an ASCII string
if(number >= 0x10){
UART_OutUHex(number/0x10);
UART_OutUHex(number%0x10);
}
else{
if(number < 0xA){
UART_OutChar(number+'0');
}
else{
UART_OutChar((number-0x0A)+'A');
}
}
}
//------------UART_InString------------
// Accepts ASCII characters from the serial port
// and adds them to a string until <enter> is typed
// or until max length of the string is reached.
// It echoes each character as it is inputted.
// If a backspace is inputted, the string is modified
// and the backspace is echoed
// terminates the string with a null character
// uses busy-waiting synchronization on RDRF
// Input: pointer to empty buffer, size of buffer
// Output: Null terminated string
// -- Modified by Agustinus Darmawan + Mingjie Qiu --
void UART_InString(char *bufPt, uint16_t max) {
int length=0;
char character;
character = UART_InChar();
while(character != CR){
if(character == BS){
if(length){
bufPt--;
length--;
UART_OutChar(BS);
}
}
else if(length < max){
*bufPt = character;
bufPt++;
length++;
UART_OutChar(character);
}
character = UART_InChar();
}
*bufPt = 0;
}
// END OF UART.c
//---------------------OutCRLF---------------------
// Output a CR,LF to UART to go to a new line
// Input: none
// Output: none
void OutCRLF(void){
UART_OutChar(CR);
UART_OutChar(LF);
}
//debug code
int main(void){
char ch;
char string[20]; // global to assist in debugging
uint32_t n;
UART_Init(); // initialize UART
OutCRLF();
for(ch='A'; ch<='Z'; ch=ch+1){// print the uppercase alphabet
UART_OutChar(ch);
}
OutCRLF();
UART_OutChar(' ');
for(ch='a'; ch<='z'; ch=ch+1){// print the lowercase alphabet
UART_OutChar(ch);
}
OutCRLF();
UART_OutChar('-');
UART_OutChar('-');
UART_OutChar('>');
while(1){
UART_OutString("InString: ");
UART_InString(string,19);
UART_OutString(" OutString="); UART_OutString(string); OutCRLF();
UART_OutString("InUDec: "); n=UART_InUDec();
UART_OutString(" OutUDec="); UART_OutUDec(n); OutCRLF();
UART_OutString("InUHex: "); n=UART_InUHex();
UART_OutString(" OutUHex="); UART_OutUHex(n); OutCRLF();
}
}
