electroSome

Using UART of PIC Microcontroller – Hi Tech C

Ligo George

UART Communication

Contents

UART stands for Universal Asynchronous Receiver / Transmitter. It is a serial communication interface which uses two lines for sending (TX) and receiving (RX) data. As its name indicates it is an asynchronous communication interface, which means it doesn’t need to send clock along with it as in synchronous communications. UART is the communication standard of our old computer’s RS-232 serial port. Most of the Microchip’s PIC Microcontrollers have built in USART Module. USART stands for Universal Synchronous Asynchronous Receiver Transmitter. It can be configured in the following Modes :

In this tutorial we are concentrating on sending and receiving data in the UART Mode using Hi-Tech C compiler. You may already know that Hi-Tech C has no built in functions for these, so we require some hardware knowledge for writing the code. I am going to explain it in deeply. If you don’t need deep knowledge in this, please skip to the coding section.

PIC 16F877A USART in Detail

USART Registers – PIC 16F877A

TXSTA – Transmit Status and Control Register

TXSTA – Transmit Status and Control Register

RCSTA – Receive Status and Control Register

RCSTA – Receive Status and Control Register

USART Baud Rate Generator (BRG)

Baud Rate Generator provides the required clock for the data transmission and reception. USART module has a dedicated 8 bit baud rate generator which supports both Synchronous and Asynchronous modes. The 8-bit SPBRG register controls the time period of this free running timer. In Asynchronous mode BRGH, 2nd bit of TXSTA register also controls the generated baud rate but in Synchronous mode it is ignored. Baud Rate can be calculated from the following equations, where FOSC is the clock frequency of the microcontroller.

PIC USART – Baud Rate Formula

Hi-Tech C Programming

Initializing UART

char UART_Init(const long int baudrate)
{
  unsigned int x;
  x = (_XTAL_FREQ - baudrate*64)/(baudrate*64); //SPBRG for Low Baud Rate
  if(x>255) //If High Baud Rate required
  {
    x = (_XTAL_FREQ - baudrate*16)/(baudrate*16); //SPBRG for High Baud Rate
    BRGH = 1; //Setting High Baud Rate
  }
  if(x<256)
  {
    SPBRG = x; //Writing SPBRG register
    SYNC = 0; //Selecting Asynchronous Mode
    SPEN = 1; //Enables Serial Port
    TRISC7 = 1;  
    TRISC6 = 1; 
    CREN = 1; //Enables Continuous Reception
    TXEN = 1; //Enables Transmission
    return 1;
  }
  return 0;
}

Note : 6th and 7th bit of TRISC registers are set as prescribed in the datasheet.

Transmitting Data through UART

Writing a Character

void UART_Write(char data)
{
  while(!TRMT); //Waiting for Previous Data to Transmit completly
  TXREG = data; //Writing data to Transmit Register, Starts transmission
}

Checking Transmit Register

This functions returns 1 if the transmit register is Empty otherwise return 0. It can be used to check whether the written data is completed transmission.

char UART_TX_Empty()
{
  return TRMT; //Returns Transmit Shift Status bit
}

Writing Text

The following function can be used to write a string or array of characters to UART. It is accomplished by continuous use of character writing function UART_Write().

void UART_Write_Text(char *text)
{
  int i;
  for(i=0;text[i]!='\\0';i++)
    UART_Write(text[i]);
}

Receiving Data Through UART

Data Received or Not

The following function can be used to check whether the data is ready to read from the Receive Register. It uses the flag bit RCIF which will be set when the data reception is completed.

char UART_Data_Ready()
{
  return RCIF;
}

Reading a Character

The following function wait till the reception is complete and reads 8 bit data from the Receive Register.

char UART_Read()
{
  while(!RCIF); //Waits for Reception to complete
  return RCREG; //Returns the 8 bit data
}

Reading Text

The following function can be used to read a desired length of text or sequence of characters continuously.

void UART_Read_Text(char *Output, unsigned int length)
{
  int i;
  for(int i=0;i<length;i++)
    Output[i] = UART_Read();
}

For simplifying the program readability we put all the above function to a header file ‘uart.h’. Thus you just need to include this header file and use required functions. For demonstrating the working of these functions we are using the following example.

PIC to PIC Communication using UART

In this example we are controlling LED’s connected to a PIC using Switch’s connected to another PIC Microcontroller. For the sake of explanation call these microcontrollers Slave and Master respectively. In the circuit diagram given below a DIP 8 Switch is connected to PORTB of the Master Microcontroller which is configured as Input Port. Pull Up resistors (10KΩ) are connected to this port to make each pin HIGH when the switch is OFF. When a Switch is turned ON, the corresponding pin will be Grounded (LOW).

Data Read from the PORTB of Master Microcontroller is send to Slave Microcontroller using UART interface. The Slave Microcontroller writes the received data to its PORTB which is configured as Output. Thus LED’s connected to Slave Microcontroller will Glow depending upon the status of the DIP Switch connected to the Master Microcontroller.

Circuit Diagram

PIC to PIC Communication – UART Example

Note : TX of Master Microcontroller is connected to RX of Slave Microcontroller and RX of Master Microcontroller is connected to the TX of Slave Microcontroller.

Hi-Tech C Codes

Master Code

#include<htc.h>

#define _XTAL_FREQ 8000000 
#include "uart.h"

void main()
{
  TRISB = 0xFF; //PORTB as Input
  UART_Init(9600); 

  do
  {
    UART_Write(PORTB);
    __delay_ms(100);
  }while(1);
}

Slave Code

#include<htc.h>
#define _XTAL_FREQ 8000000 //Clock Frequency
#include "uart.h"

void main()
{
   TRISB = 0x00; //PORTB as Output
   UART_Init(9600);

   do
   {
      if(UART_Data_Ready())       
        PORTB = UART_Read();
     __delay_ms(100);

   }while(1);
}

Note : Don’t forget to add Header file to the Project Folder and File list before compiling.

Adding a Header File

Download Here

You can download ‘uart.h’ header file, Hi-Tech C and Proteus files here…

Using UART PIC Microcontroller – Hi Tech C

Exit mobile version