Skip to main content

AVR Serial Communication Tutorial (UART)

First, a quick history of RS232. What is RS232? It's just a name for a standard that has propagated from generation to generation of computers. The first computers had serial ports that used RS232, and even current computers have serial ports (or at least USB ports that act like RS232 ports). Back in the day, serial information needed to be passed from devices like printers, joysticks, scanners, etc to the computer. The simplest way to do this was to pass a series of 1s and 0s to the computer. Both the computer and the device agreed on a speed of information - 'bits per second'. A computer would pass image data to a printer at 9600 bits per second and the printer would listen for this stream of 1s and 0s expecting a new bit every 1/9600 = 104us (104 micro-seconds, 0.000104 seconds). As long as the computer output bits at the pre-determined speed, the printer could listen.
Zoom forward to today. Electronics have changed a bit. Before they were relatively high power, high voltage devices. The standard that is 'RS232' dictates that a bit ranges from -12V to +12V. Modern electronics do not operate at such high positive and negative voltages. In fact, our AVR  runs 0V to 5V. So how do we get our 5V micro to talk the RS232 +/-12V voltages? This problem has been solved by the IC manufacturers of the world. They have made an IC that is generically known as the MAX232 (very close to RS232, no?).
The MAX232 is an IC originally designed by a company called Maxim IC that converts the +/-12V signals of RS232 down to the 0/5V signals that our AVR  can understand. It also boosts the voltage of our AVR  to the needed +/-12V of the RS232 protocol so that a computer can understand our AVR  and vice versa. To get our AVR  IC sending serial characters to a computer, we have to send these serial signals through a MAX232 circuit so that the computer receives +/-12V RS232 signals. Don't worry if you're working with a chip labeled 'ICL232' or 'ST232' - these are just generics of the MAX232. Everyone says 'MAX232'. The ICs all function the same and nearly all have the same pinout. 


Schematic Diagram 







The UART hardware module is available with a number of AVR MCUs. mikroC PRO for AVR UART Library provides comfortable work with the Asynchronous (full duplex) mode.
You can easily communicate with other devices via RS-232 protocol (for example with PC, see the figure at the end of the topic – RS-232 HW connection). You need a AVR MCU with hardware integrated UART, for example ATmega16. Then, simply use the functions listed below.
  Important :
  • AVR MCUs require you to specify the module you want to use. To select the desired UART, simply change the letter x in the prototype for a number from 1 to 4. Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
  • For the XMEGA family of MCUs change the X in the routine prototype with C0, C1, D0, D1, E0, E1, F0 or F1 (MCU dependent).
  • Some of the AVR MCUs do not support UARTx_Init_Advanced routine. Please, refer to the appropriate datasheet.
  • Some AVR MCUs have multiple UART modules. Switching between the UART modules in the UART library is done by the UART_Set_Active function (UART module has to be previously initialized).
Library Routines
Generic Routines
UARTx_Init
Prototype
void UARTx_Init(unsigned long baud_rate);
Returns
Nothing.
Description
Configures and initializes the UART module.
The internal UART module module is set to :
  • receiver enabled
  • transmitter enabled
  • frame size 8 bits
  • 1 STOP bit
  • parity mode disabled
  • asynchronous operation
Parameters :
  • baud_rate: requested baud rate
Refer to the device data sheet for baud rates allowed for specific Fosc.
  Note :
  • Calculation of the UART baud rate value is carried out by the compiler, as it would produce a relatively large code if performed on the libary level.
    Therefore, compiler needs to know the value of the parameter in the compile time. That is why this parameter needs to be a constant, and not a variable.
  • Also, UART baud rate it is calculated under assumption that peripheral clock is equal to the system clock.
Requires
You'll need AVR MCU with hardware UART.
UARTx_Init needs to be called before using other functions from UART Library.
Example
// Initialize hardware UART1 and establish communication at 9600 bps
UART1_Init(9600);
UARTx_Init_Advanced
Prototype
void UARTx_Init_Advanced(unsigned long baud_rate, char parity, char stop_bits);
Returns
Nothing.
Description
Configures and initializes UART module.
Parameter baud_rate configures UART module to work on a requested baud rate.
Parameters
parity and stop_bits determine the work mode for UART, and can have the following values:
Description
Predefined library const
Parity constants:
Parity mode disabled
_UART_NOPARITY
Even parity
_UART_EVENPARITY
Odd parity
_UART_ODDPARITY
Stop bit constants:
1 stop bit
_UART_ONE_STOPBIT
2 stop bits
_UART_TWO_STOPBITS
  Note :
  • Some MCUs do not support advanced configuration of the UART module. Please consult appropriate daatsheet.
  • Calculation of the UART baud rate value is carried out by the compiler, as it would produce a relatively large code if performed on the libary level.
    Therefore, compiler needs to know the value of the parameter in the compile time. That is why this parameter needs to be a constant, and not a variable.
  • Also, UART baud rate it is calculated under assumption that peripheral clock is equal to the system clock.
Requires
MCU must have UART module.
Example
// Initialize hardware UART1 module and establish communication at 9600 bps, 8-bit data, even parity and 2 STOP bits
UART1_Init_Advanced(9600, _UART_EVENPARITY, _UART_TWO_STOPBITS);
UARTx_Data_Ready
Prototype
char UARTx_Data_Ready();
Returns
  • 1 if data is ready for reading
  • 0 if there is no data in the receive register
Description
Use the function to test if data in receive buffer is ready for reading.
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
// If data is ready, read it:
if (UART1_Data_Ready() == 1) {
 receive = UART1_Read();
 }
UARTx_Tx_Idle
Prototype
char UARTx_Tx_Idle();
Returns
  • 1 if the data has been transmitted
  • 0 otherwise
Description
Use the function to test if the transmit shift register is empty or not.
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
// If the previous data has been shifted out, send next data:
if (UART1_Tx_Idle() == 1) {
  UART1_Write(_data);
 }
UARTx_Read
Prototype
char UARTx_Read();
Returns
Returns the received byte.
Description
Function receives a byte via UART. Use the UARTx_Data_Ready function to test if data is ready first.
Requires
The UART module must be initialized before using this routine. See UARTx_Init routine.
Example
// If data is ready, read it:
if (UART1_Data_Ready() == 1) {
 receive = UART1_Read();
 }
UARTx_Read_Text
Prototype
void UARTx_Read_Text(char *Output, char *Delimiter, char Attempts);
Returns
Nothing.
Description
Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter output; delimiter sequence is stored in the parameter delimiter.
This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found).
Parameters :
  • Output: received text
  • Delimiter: sequence of characters that identifies the end of a received string
  • Attempts: defines number of received characters in which Delimiter sequence is expected. If Attempts is set to 255, this routine will continuously try to detect the Delimiter sequence.
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
Read text until the sequence “OK” is received, and send back what’s been received:
UART1_Init(4800);                         // initialize UART1 module
Delay_ms(100);

while (1) {
  if (UART1_Data_Ready() == 1) {          // if data is received
    UART1_Read_Text(output, "OK", 10);    // reads text until 'OK' is found
    UART1_Write_Text(output);             // sends back text
 }
}
UARTx_Write
Prototype
void UARTx_Write(char data_);
Returns
Nothing.
Description
The function transmits a byte via the UART module.
Parameters :
  • data_: data to be sent
Requires
MCU with the UART module.
The UART module must be initialized before using this routine. See UARTx_Init routine.
Example
unsigned char data_ = 0x1E;
...
UART1_Write(data_);
UARTx_Write_Text
Prototype
void UARTx_Write_Text(char * UART_text);
Returns
Nothing.
Description
Sends text via UART. Text should be zero terminated.
Parameters :
  • UART_text: text to be sent
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
Read text until the sequence “OK” is received, and send back what’s been received:
UART1_Init(4800);                         // initialize UART1 module
Delay_ms(100);

while (1) {
  if (UART1_Data_Ready() == 1) {          // if data is received
    UART1_Read_Text(output, "OK", 10);    // reads text until 'OK' is found
    UART1_Write_Text(output);             // sends back text
 }
}
UART_Set_Active
Prototype
void UART_Set_Active(char (*read_ptr)(), void (*write_ptr)(unsigned char data_), char (ready_ptr)(), char (*tx_idle_ptr)())
Returns
Nothing.
Description
Sets active UART module which will be used by the UART library routines.
Parameters :
Requires
Routine is available only for MCUs with multiple UART modules.
Used UART module must be initialized before using this routine. See UARTx_Init routine
Example
UART1_Init(9600);                    // initialize UART1 module
UART2_Init(9600);                    // initialize UART2 module

RS485Master_Init();                  // initialize MCU as Master

UART_Set_Active(&UART1_Read, &UART1_Write, &UART1_Data_Ready, &UART1_Tx_Idle); // set UART1 active
RS485Master_Send(dat,1,160);        // send message through UART1

UART_Set_Active(&UART2_Read, &UART2_Write, &UART2_Data_Ready, &UART2_Tx_Idle); // set UART2 active
RS485Master_Send(dat,1,160);        // send through UART2
UART_Data_Ready
Prototype
char UART_Data_Ready();
Returns
  • 1 if data is ready for reading
  • 0 if there is no data in the receive register
Description
Use the function to test if data in receive buffer is ready for reading.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
// If data is ready, read it:
if (UART_Data_Ready() == 1) {
 receive = UART_Read();
 }
UART_Tx_Idle
Prototype
char UART_Tx_Idle();
Returns
  • 1 if the data has been transmitted
  • 0 otherwise
Description
Use the function to test if the transmit shift register is empty or not.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
// If the previous data has been shifted out, send next data:
if (UART_Tx_Idle() == 1) {
  UART_Write(_data);
 }
UART_Read
Prototype
char UART_Read();
Returns
Returns the received byte.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Description
Function receives a byte via UART. Use the UART_Data_Ready function to test if data is ready first.
Requires
The UART module must be initialized before using this routine. See UARTx_Init routine.
Example
// If data is ready, read it:
if (UART_Data_Ready() == 1) {
 receive = UART_Read();
 }
UART_Read_Text
Prototype
void UART_Read_Text(char *Output, char *Delimiter, char Attempts);
Returns
Nothing.
Description
Reads characters received via UART until the delimiter sequence is detected. The read sequence is stored in the parameter output; delimiter sequence is stored in the parameter delimiter.
This is a blocking call: the delimiter sequence is expected, otherwise the procedure exits (if the delimiter is not found).
Parameters :
  • Output: received text
  • Delimiter: sequence of characters that identifies the end of a received string
  • Attempts: defines number of received characters in which Delimiter sequence is expected. If Attempts is set to 255, this routine will continuously try to detect the Delimiter sequence.
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
Read text until the sequence “OK” is received, and send back what’s been received:
UART_Init(4800);                         // initialize UART1 module
Delay_ms(100);

while (1) {
  if (UART_Data_Ready() == 1) {          // if data is received
    UART_Read_Text(output, "OK", 10);    // reads text until 'OK' is found
    UART_Write_Text(output);             // sends back text
 }
}
UART_Write
Prototype
void UART_Write(char data_);
Returns
Nothing.
Description
The function transmits a byte via the UART module.
Parameters :
  • data_: data to be sent
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires
MCU with the UART module.
The UART module must be initialized before using this routine. See UARTx_Init routine.
Example
unsigned char data_ = 0x1E;
...
UART_Write(data_);
UART_Write_Text
Prototype
void UART_Write_Text(char * UART_text);
Returns
Nothing.
Description
Sends text via UART. Text should be zero terminated.
Parameters :
  • UART_text: text to be sent
This is a generic routine which uses the active UART module previously activated by the UART_Set_Active routine.
Requires
UART HW module must be initialized and communication established before using this function. See UARTx_Init.
Example
Read text until the sequence “OK” is received, and send back what’s been received:
UART_Init(4800);                         // initialize UART1 module
Delay_ms(100);

while (1) {
  if (UART_Data_Ready() == 1) {          // if data is received
    UART_Read_Text(output, "OK", 10);    // reads text until 'OK' is found
    UART_Write_Text(output);             // sends back text
 }
}
Code
The tutorial demonstrates a simple data exchange via UART. When AVR MCU receives data, it immediately sends it back. If AVR is connected to the PC (see the figure below), you can test the example from the mikroC PRO for AVR terminal for RS-232 communication, menu choice Tools › Terminal.

char uart_rd;

void main() {

  UART1_Init(9600);               // Initialize UART module at 9600 bps
  Delay_ms(100);                  // Wait for UART module to stabilize
  UART1_Write_Text("Init");
  UART1_Write(13);UART1_Write(10);
  while (1) {                     // Endless loop
   if (UART1_Data_Ready()) {      // If data is received,
     uart_rd = UART1_Read();      // read the received data,
     UART1_Write(uart_rd);        // and send data via UART
    }
  }
}
}


Comments

  1. awesome tutorial keep-it up
    thanks
    www.onlinetps.com/shop

    ReplyDelete
  2. #include<16f877a.h>
    #device ADC=10
    #fuses HS,NOWDT
    #use delay(clock=4000000)
    #use rs232(baud=57600,parity=N,xmit=PIN_C6)
    #bit LCD_RS=0x8.2 //0x5.3
    #bit LCD_RW=0x8.0 //0x5.2
    #bit LCD_EN=0x8.3 //0x5.1

    #byte LCD_DATA=8

    #define LCD_STROBE() ((LCD_EN=1),(LCD_EN=0))

    void lcd_char(unsigned char c);
    int16 value,value1;
    char w,x,y,z,p,q;
    unsigned char str1[]="L:";
    void main()
    {
    set_tris_d(0x00);
    set_tris_a(0x0F);
    while(TRUE)
    [
    set_tris_a(0x0F);


    setup_adc(ADC_CLOCK_INTERNAL);
    setup_adc_ports (ALL_ANALOG);
    set_adc_channel(0);

    delay_ms(1000);
    value=read_adc();
    value1=value;
    z=value1%10;
    value1=value1/10;
    y=value1%10;
    value1=value1/10;
    x=value1%10;

    x

    if(x!=0)
    {
    lcd_char(x+0x30);
    }
    lcd_char(y+0x30);
    lcd_char('.');
    lcd_char(z+0x30);
    lcd_char('L');


    delay_ms(1000);



    this is my code for light intensity. by using this code i saw the result on LCD. can any one tell me by adding what i saw this result on pc. i am using rs232 for communication. i have max232 i know how to connect but what modification are needed in this code so i saw on pc.the LCD function have properly work

    ReplyDelete
  3. See this post

    http://microcontrollerprojects00.blogspot.in/2012/10/pc-based-digital-voltmeter-using-pic.html?utm_source=BP_recent

    ReplyDelete
  4. How can I see or download Source file for these functions???

    ReplyDelete
  5. This is my AVR Atmega16a code using 16MHz oscillator , i am expecting some character in hyperterminal window thats all,
    my result is ......... in hexa 00 00 00 00 pls help me some one , i appreciating them :) pls
    /*
    * uart.c
    *
    * Created: 03-06-2014 PM 04:20:03
    * Author: srinivas
    */

    #define F_CPU 16000000UL
    #define BAUD 9600
    #define BAUDRATE ((F_CPU)/(BAUD*16UL)-1)
    #include
    #include
    #include
    //#include


    // function to init uart
    void uart_init (void)
    {
    UCSRC = (0<>8);
    UBRRL = BAUDRATE;
    _delay_ms(10);
    UCSRB = (1<<TXEN)|(1<<RXEN);
    _delay_ms(10);
    UCSRC = (1<<URSEL)|(0<<USBS)|(3<<UCSZ0);
    _delay_ms(10);
    }

    void uart_transmit (unsigned char data)
    {
    while (!( UCSRA & (1<<UDRE)));
    UDR = data;
    _delay_ms(20);
    }

    void uart_string(char *str )
    {
    while(*str)
    {
    uart_transmit(*str++);
    _delay_ms(1);
    }
    }
    // function to rec data
    unsigned char uart_recieve (void)
    {
    while(!(UCSRA & (1<<RXC)));
    return UDR; //8bit data
    }

    int main()
    {
    //uart_init();
    uart_init();
    _delay_ms(100);
    while(1)
    {
    uart_transmit ('g');
    //_delay_ms(10);
    //uart_string("zz");
    //printf("ih");
    _delay_ms(100);
    //puts("hi");
    }
    return 0;
    }

    ReplyDelete

  6. ********************************************************
    ----BUY ELECTRONIC COMPONENTS AND GADGETS ONLINE AT-----

    ............ www.kimaginations.com .................

    ===============LOWEST PRICE IN INDIA ===================

    (Get Exciting Offers and Discounts)

    (ROBOTICS,EMBEDDED,VLSI KITS,MATERIALS AND PROJECTS)

    USE COUPON CODE : KI100DISC

    *GET Rs. 100 /- OFF ON PURCHASE


    ********************************************************
    *T&C Apply

    ReplyDelete
  7. Avr Serial Communication Tutorial (Uart) >>>>> Download Now

    >>>>> Download Full

    Avr Serial Communication Tutorial (Uart) >>>>> Download LINK

    >>>>> Download Now

    Avr Serial Communication Tutorial (Uart) >>>>> Download Full

    >>>>> Download LINK 2f

    ReplyDelete

Post a Comment

Popular posts from this blog

PIC 16F877A Microcontroller Based Electronic Lock 16x2LCD 4x3 Keypad

 Circuit Diagram Security is a prime concern in our day-today life. Everyone wants to be as much secure as possible. An access control for doors forms a vital link in a security chain. The microcontroller based digital lock for Doors is an access control system that allows only authorized persons to access a restricted area. An electronic lock or digital lock is a device which has an electronic control assembly attached to it. They are provided with an access control system. This system allows the user to unlock the device with a password. The password is entered by making use of a keypad. The user can also set his password to ensure better protection. The major components include a Keypad, LCD and the controller PIC16F877A. This article describes the making of an electronic code lock using the 16F877A microcontroller. The system is fully controlled by the 8 bit microcontroller 16F877A which has a 8Kbytes of ROM for the program memory. The password is stored in the

Electronic Voting Machine Using 8051 Microcontroller (AT89C51)

  Circuit Electronic voting machine has now replaced the traditional mechanism of voting due to several advantages like security, automatic counting etc. This project presents a way to develop an electronic voting machine which displays the count of votes on a 16x2 LCD interface. A user can get his/her vote register through a set of switches (one for each candidate). After every cast of vote, the subsequent count can be seen on LCD. The circuit uses AT89C51 microcontroller and the code for the project has been written in C. This LCD based electronic voting machine is designed for four candidates. The input part consists of a set of six tactile switches. The switches and 16x2 LCD are interfaced to microcontroller AT89C51 for various operations and displays. The provision of casting votes for the candidates has been provided through four of these switches. These switches are made active high and connected to pins 2-5 (P1^1 – P1^4) of the controller. The remaining two

89C51 Based Digital Thermometer Using DS1820

Introduction The hardware configuration when using multiple 1-Wire temperature sensors like the DS1820 is very simple, as illustrated in the block diagram below. A single-wire bus is used for communication between the microcontroller and the temperature sensor. It is also possible to power the devices direclty via this 1-Wire bus. An almost unlimited number of 1-WireTM devices can be connected to the bus because each device has a unique 64-bit ROM code identifier which is used to address each sensor   Temperature measurement using DS1820 sensor. Use of ‘1-wire’ protocol... Temperature measurement is one of the most common tasks performed by the microcontroller. A DS1820 sensor is used for measurement here. It is capable of measuring temperature in the range of -55 °C to 125 °C with 0.5 °C accuracy. For the purpose of transferring data to the microcontroller, a special type of serial communication called 1-wire is used. Due to a simple and wide use of these sensors, commands us