Using the USART/serial [tutorial part 2]

Hello again, today I will continue with my tutorial series and I write a bit about the USART(or UART in other avr models), the USART give us the possibility to have a serial port, and that is a pretty nice thing to have, because it can be used for example to upload programs to our Arduino(via bootloader), to have a communication channel between our micro-controller and our computer, or to talk to some sensors/chips, the most used ones are serial backpacks for lcd’s and graphical lcd’s and GPS modules that use almost always an serial interface.
The serial protocol is a fairly old protocol created many years ago it was used by Teletypes and terminals, its also a robust protocol(at least when we use the RS-232 standard that involves +12v and -12v or more so its immune to noise and can cope with long transmission lines), the serial protocol uses 2 wires, one to receive data and other to send data, and of course you must have a shared ground between your arduino/micro-controller and the other device. The serial interface sends the data in little blocks of one byte with one start bit and one stop bit, the USART does all the job about the setting of the start and stop bits. The clock signal of the serial protocol is implicit, this means that is is “joined” with the data stream and there is no need to have a separate wire to transmit the clock from one device to another, we only need to say to the USART which clock speed we want to use(this is the baud rate) and again the USART module will do all the heavy lifting.

If you want to know a bit more about the RS-232 protocol read this Wikipedia page, its also good to know a bit more about the protocol, but not mandatory:
http://en.wikipedia.org/wiki/RS-232

Also, its always good to have the datasheet of the atmega328p in hand as it as all the information that we will need, link here:

Click to access doc8271.pdf

And we can also create a small stub program, this will be our base program that we use every time that we start a new project in AvrStudio, it as the basic includes and the main function:

#define F_CPU 16000000UL        //Says to the compiler which is our clock frequency, permits the delay functions to be very accurate
#include <avr/io.h>            /General definitions of the registers values
#include <util/delay.h>            //This is where the delay functions are located

int main(void){                //The begin of our main function
 //This is where our code goes

return 0;                //As usual all non-void functions must have a return
}

This is a little but handy stub and it also saves us the time to write is every time we start a new project.

Now talking specifically about the USART module and how to create a program to use it. In this tutorial instead of just putting all the code together in the main function I will instead create some basic functions, so if you want to use serial comm in another project you just have to copy the functions and call then where they are needed.
So, in pseudo-code this is what we need to do:

Start and setup of the USART
Create a function to send a byte/char
Create a function to receive a byte/char
Make a simple echo program in our main function

Now we know what we want to do, but how? Well we open the datasheet and we start to read it, luckily the datasheet is ordered by chapters so we can jump to the USART chapter(page 177, section 19) and there we can see that there is even some sample code in C and assembly so our work here is a bit easier than we though, so lets start with the initialization code:

void USART_init(void){

 UBRR0H = (uint8_t)(BAUD_PRESCALLER>>8);
 UBRR0L = (uint8_t)(BAUD_PRESCALLER);
 UCSR0B = (1<<RXEN0)|(1<<TXEN0);
 UCSR0C = ((1<<UCSZ00)|(1<<UCSZ01));
}

Lets explain what all those strange names mean, UBRR0H and UBRR0L are the registers where we set the baudrate, but not directly, in this two registers we put a value that is dependent of the baudrate that we want to use(for example 9600) and the cpu(crystal) frequency, and to arrive to that value there are two ways, one is to read the tables provided by the datasheet(in the USART section, near the end) or use the little formula that was used to generate those values present in the datasheet, the last option is better, because we can just use the #define directive and have the compiler do all the maths, and we can just change the baudrate and re-compile the code, so we don’t have to go read the datasheet everytime we want to change the baudrate or if we use a different cristal with different frequency than the 16Mhz, so here is the formula:

]#define BAUD 9600        //The baudrate that we want to use
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)    //The formula that does all the required maths

Now about the UCSR0B is the register that control if the Rx(receive, this is the one activated by the RXEN0 bit) and Tx(transmit/send, this is the one activated by the TXEN0 bit) pins(in Arduino those are the digital 0 and 1) are activated or not, also this is where we can enable the interrupts associated with the USART, but we will not use those for now. And the UCSR0C is the register that as some more configuration bits, this one is a bit more protocol specific, this is where we configure the data bits lenght, parity check and number of stop bits, I have chosen the 8N1 settings because its the most common settings for serial comm, and the meaning of the UCSZ00 and UCZS01 bits I leave to the reader as a simple exercise to motive the reading of the datasheet.

To initialize our USART we just need to call the USART_init() function and its done(I said it was easy). Lets see the code that we need to use to send one char from the Arduino, this code is again provided by the datasheet, and here it is:

void USART_send( unsigned char data){

 while(!(UCSR0A & (1<<UDRE0)));
 UDR0 = data;

}

The first line is a bit odd, but it as its reasons, that line is checking if there is space in the Atmega send buffer(the atmega chip as a small 3 byte hardware buffer in the TX/send channel) to put a new char/byte, if yes the char/byte is loaded into the UDR0 register which makes part of the USART hardware and if something is loaded into that register it will be sent by the USART, again this is very simple, with only 2 lines we can already send data using the serial port!
And finally the function used to receive one char is also present in the datasheet and is again a two lines solution:

unsigned char USART_receive(void){

 while(!(UCSR0A & (1<<RXC0)));
 return UDR0;

}

In the first line the while loop is used to pool the receive register, and if there is new data in that register we return the data, as you can see its pretty simple. As an extra not shown in the datasheet I will show how to send one string via the serial comm, this is a useful function because there are plenty of situations where we need to send much more than one byte/char so lets build an USART_putstring function to help us, this functions takes advantage of the fact that in C every string is terminated with a null character, this means that the last char is always 0, so using this and our USART_send function here is the USART_putstring function:

void USART_putstring(char* StringPtr){

while(*StringPtr != 0x00){    //Here we check if there is still more chars to send, this is done checking the actual char and see if it is different from the null char
 USART_send(*StringPtr);    //Using the simple send function we send one char at a time
 StringPtr++;}        //We increment the pointer so we can read the next char

}

Now we have all the necessary functions to have a simple yet usable serial interface between the Arduino and a computer or other sensor, so lets evolve to a more glorious “Hello world!!” program, the only thing left is a Serial Terminal so we can see what the Arduino is saying and we can also send it some commands, I recommend this simple to use Serial Terminal:
http://www.smileymicros.com/download/term20040714.zip?&MMN_position=42:42

As far as I know it is made by an AvrFreaks member and its easy to use and its only a single file, no install required, just download and open.
Lets grab in our stub code and our functions and pu then all together:

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>

#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)

//Declaration of our functions
void USART_init(void);
unsigned char USART_receive(void);
void USART_send( unsigned char data);
void USART_putstring(char* StringPtr);

char String[]="Hello world!!";    //String[] is in fact an array but when we put the text between the " " symbols the compiler threats it as a String and automatically puts the null termination character in the end of the text

int main(void){
USART_init();        //Call the USART initialization code

while(1){        //Infinite loop
 USART_putstring(String);    //Pass the string to the USART_putstring function and sends it over the serial
 _delay_ms(5000);        //Delay for 5 seconds so it will re-send the string every 5 seconds
 }

return 0;
}

void USART_init(void){

 UBRR0H = (uint8_t)(BAUD_PRESCALLER>>8);
 UBRR0L = (uint8_t)(BAUD_PRESCALLER);
 UCSR0B = (1<<RXEN0)|(1<<TXEN0);
 UCSR0C = (3<<UCSZ00);
}

unsigned char USART_receive(void){

 while(!(UCSR0A & (1<<RXC0)));
 return UDR0;

}

void USART_send( unsigned char data){

 while(!(UCSR0A & (1<<UDRE0)));
 UDR0 = data;

}

void USART_putstring(char* StringPtr){

while(*StringPtr != 0x00){
 USART_send(*StringPtr);
 StringPtr++;}

}

And that’s it, using this we can send data via the USART/serial port, so lets open AvrStudio and create a new project called USART.

Then in the next window we can verify that the project will be created inside our AVR folder, so just fill the Project Name with USART and font forget to choose the Avr-gcc as the compiler.

After pressing Next choose your Avr model, for the Arduino UNO/duemilanove its Atmega328p.

And finally press Finish and copy and paste the code given here to the editor, and to compile you can press F7 or click in the button marked in green in this image:

As you can see this code will compile with any errors or warnings and we can open the Command line to upload the program to the Arduino board, if you don’t remember how its done just go to the first tutorial and see again how its done, but this time the folder is called USART and not blinky, then go again to the default folder that is inside the USART folder, the default folder is where the compiler puts its file, including the .hex file which is the one that as the code compiled and ready to be programmed in the Arduino.

Now lets just call the avrdude and again check the .hex name and make sure you are using the correct COM port.

With the upload done we can now open our Terminal program, and again you need to choose the correct COM port, it will be the same as the one used in the avrdude, and lets configure the Terminal so it can listen to our Arduino, the baudrate is 9600, 8 data bits, 1 stop bit and no parity, see this image:

You just need to press the Connect button and press the Reset button in your Arduino so the Terminal can sync with the serial stream that is coming from the Arduino and you should see something like this:

And you are done, just remember one thing, if you have the Terminal connected you cant send any programs to the Arduino using the Avrdude, you must first disconnect and then send the program.

And here is the code ready to open in Avr Studio 4, hosted by the great Google Code:

http://code.google.com/p/avr-tutorials/downloads/detail?name=serial.zip

Happy programming!!