Serial communications

Cornell University
Electrical Engineering 476
RS232 serial communications
with AVR microcontrollers

Introduction

Most of the AVR mcus have a hardware UART. You can use the UART in CodevisionC with the usual stdio library functions, plus a few designed for this small mcu. You should note that all of the CodevisionC stdio functions are blocking. This means that any cooperative multitasking scheme you use will halt if you use stdio functions. A couple of approachs to solving this problem will be outlined below.

Near the bottom of the page there is code for using the UART in assembler.

If you use the UART to talk to a PC, the UART should be connected to a COM port of the PC. You should use a simple terminal program, such as Hyperterminal, on the PC. The terminal program should be set to 9600 baud, no parity, one stop bit, and no flow control. The connection to the PC for the AVR development board assumes a RS232 cable with straight-through connection. The STK500 board requires a jumper from port pins D0 and D1 to the RS232-spare header.

Using C stdio library

In C, you need to specifically enable the UCR (UCSRB on Mega163 and Mega32) to transmit and receive, and define the baud rate in UBRR (UBRRL on Mega32). These two lines must preceed any of the higher-level serial i/o commands. Setting the UCR (UCSRB) to 0x18 enables serial transmit and receive. Setting the UBRR to 51 implies 9600 baud with an 8 MHz crystal. See the MCU data sheet for other baud rates.

 //For 8515:

UCR = 0x10 + 0x08 ; //turn on serial transmit/receive

UBRR = 51 ; //using a 8 MHz crystal

//

//For Mega163:

UCSRB = 0x10 + 0x08 ;

UBRR = 51 ; //using a 8 MHz crystal

//

//For Mega32:

UCSRB = 0b00011000 ; //hex 0x18

UBRRL = 103 ; //using a 16 MHz crystal (9600 baud)

In addition if you want to enable the receive-complete interrupt you must instead set
USCRB = 0b10011000; //hex 0x98
Bit 7 enables the interrupt, bit 4 enables the receiver, and bit 3 the transmitter.

Printf and scanf are supplied. Floating point conversion support costs you a lot of code space if you use it. There are also put-string and get-string commands (puts, gets), as well as putsf, which means put-string-from-flash-memory. The lower-level commands putchar and getchar are also available. Since there are 32 kbytes of flash memory and only 2 kbytes of RAM, you should always store constant strings in flash. In the following example, the fragment of code prompts the user with a string from flash memory, then waits for an 's' from the serial port. All quoted literal strings used as parameters are automatically stored in flash.

putsf("Press s to stop\r"); 
sflag = 0;
while(sflag!='s') sflag = getchar() ;

The input function, scanf, does not echo characters back to hyperterm. You can do this, and have a backspace function, by using something similar to this code.

Avoiding Blocking Input in C

Usually you can tolerate a blocking stdio function when it is used for output (e.g. printf) because you can estimate the length of time the transmission will take and because embedded applications tend to sent short strings. However, if you are waiting for input from a user, an input function (e.g. scanf) could wait for a very long time. This will cause a cooperative multitasking program organization to fail. You can work around this problem in two fundamentally different ways:

Be sure that there is actually a character to be read before calling getchar(). You can do this by polling the UART status register every few mSec. An example of this scheme is shown in an example on the Program Organization page.
Write a receive interrupt routine so that getchar() is only called when the receive-done flag is set by hardware. The receive interrupt routine will also be responsible for collecting the inputted characters into a string until detecting a enter keystroke, then null-terminating the string and setting a flag showing that the string is complete. Also write a transmit interrupt which sends one character, then enters the ISR when the transmit-buffer-empty flag is set. An example shows one way to implement this. Note that you must turn on the printf feature to print longs in the project...configure dialog.

Serial communication in ASM

There are at least two ways of handling serial i/o in assembly language:

Polled transmit and receive functions. This scheme blocks the cpu while executing, but is often easier to setup. A demo program shows fairly high-level string send and receive functions. Another demo program shows one way of parsing numbers from from an input string.
Interrupt driven transmit and receive functions. This scheme allows the fast cpu to perfrom other functions while waiting for the slow serial interface. A demo program shows basic UART transmit and receive interrupt routines for the AT90S8515 mcu. Note that the 'transmit buffer empty" interrupt is set when the mcu is reset. This means that you must initialize the message pointer before you enable interrupts, or you will get garbage sent to the terminal at each reset.