8051 4 Bit LCD Interfacing Tutorial

Click Here For Character LCD Basics

 

Lcd Library

The mikroC PRO for 8051 provides a library for communication with Lcds (with HD44780 compliant controllers) through the 4-bit interface. An example of Lcd connections is given on the schematic at the bottom of this page.
For creating a set of custom Lcd characters use Lcd Custom Character Tool.

External dependencies of Lcd Library

The following variables must be defined in all projects using Lcd Library :	Description :	Example :
extern sfr sbit LCD_RS:	Register Select line.	sbit LCD_RS at P2_0_bit;
extern sfr sbit LCD_EN:	Enable line.	sbit LCD_EN at P2_1_bit;
extern sfr sbit LCD_D7;	Data 7 line.	sbit LCD_D7 at P2_5_bit;
extern sfr sbit LCD_D6;	Data 6 line.	sbit LCD_D6 at P2_4_bit;
extern sfr sbit LCD_D5;	Data 5 line.	sbit LCD_D5 at P2_3_bit;
extern sfr sbit LCD_D4;	Data 4 line.	sbit LCD_D4 at P2_2_bit;

Library Routines

• Lcd_Init
• Lcd_Out
• Lcd_Out_Cp
• Lcd_Chr
• Lcd_Chr_Cp
• Lcd_Cmd

Lcd_Init

Prototype	void Lcd_Init();
Returns	Nothing.
Description	Initializes Lcd module.
Requires	Global variables: LCD_D7: data bit 7 LCD_D6: data bit 6 LCD_D5: data bit 5 LCD_D4: data bit 4 RS: register select (data/instruction) signal pin EN: enable signal pin must be defined before using this function.
Example	// lcd pinout settings   sbit LCD_RS at P2_0_bit; sbit LCD_EN at P2_1_bit; sbit LCD_D7 at P2_5_bit; sbit LCD_D6 at P2_4_bit; sbit LCD_D5 at P2_3_bit; sbit LCD_D4 at P2_2_bit;   ...   Lcd_Init();

Lcd_Out

Prototype	void Lcd_Out(char row, char column, char *text);
Returns	Nothing.
Description	Prints text on Lcd starting from specified position. Both string variables and literals can be passed as a text. Parameters : row: starting position row number column: starting position column number text: text to be written
Requires	The Lcd module needs to be initialized. See Lcd_Init routine.
Example	// Write text "Hello!" on Lcd starting from row 1, column 3: Lcd_Out(1, 3, "Hello!");

Lcd_Out_CP

Prototype	void Lcd_Out_Cp(char *text);
Returns	Nothing.
Description	Prints text on Lcd at current cursor position. Both string variables and literals can be passed as a text. Parameters : text: text to be written
Requires	The Lcd module needs to be initialized. See Lcd_Init routine.
Example	// Write text "Here!" at current cursor position: Lcd_Out_CP("Here!");

Lcd_Chr

Prototype	void Lcd_Chr(char row, char column, char out_char);
Returns	Nothing.
Description	Prints character on Lcd at specified position. Both variables and literals can be passed as a character. Parameters : row: writing position row number column: writing position column number out_char: character to be written
Requires	The Lcd module needs to be initialized. See Lcd_Init routine.
Example	// Write character "i" at row 2, column 3: Lcd_Chr(2, 3, 'i');

Lcd_Chr_CP

Prototype	void Lcd_Chr_Cp(char out_char);
Returns	Nothing.
Description	Prints character on Lcd at current cursor position. Both variables and literals can be passed as a character. Parameters : out_char: character to be written
Requires	The Lcd module needs to be initialized. See Lcd_Init routine.
Example	// Write character "e" at current cursor position: Lcd_Chr_CP('e');

Lcd_Cmd

Prototype	void Lcd_Cmd(char out_char);
Returns	Nothing.
Description	Sends command to Lcd. Parameters : out_char: command to be sent Note: Predefined constants can be passed to the function, see Available Lcd Commands.
Requires	The Lcd module needs to be initialized. See Lcd_Init table.
Example	// Clear Lcd display: Lcd_Cmd(_LCD_CLEAR);

Available Lcd Commands

Lcd Command	Purpose
_LCD_FIRST_ROW	Move cursor to the 1st row
_LCD_SECOND_ROW	Move cursor to the 2nd row
_LCD_THIRD_ROW	Move cursor to the 3rd row
_LCD_FOURTH_ROW	Move cursor to the 4th row
_LCD_CLEAR	Clear display
_LCD_RETURN_HOME	Return cursor to home position, returns a shifted display to its original position. Display data RAM is unaffected.
_LCD_CURSOR_OFF	Turn off cursor
_LCD_UNDERLINE_ON	Underline cursor on
_LCD_BLINK_CURSOR_ON	Blink cursor on
_LCD_MOVE_CURSOR_LEFT	Move cursor left without changing display data RAM
_LCD_MOVE_CURSOR_RIGHT	Move cursor right without changing display data RAM
_LCD_TURN_ON	Turn Lcd display on
_LCD_TURN_OFF	Turn Lcd display off
_LCD_SHIFT_LEFT	Shift display left without changing display data RAM
_LCD_SHIFT_RIGHT	Shift display right without changing display data RAM

Code

The following code demonstrates usage of the Lcd Library routines:


// Lcd module connections
sbit LCD_RS at P2_0_bit;
sbit LCD_EN at P2_1_bit;

sbit LCD_D4 at P2_2_bit;
sbit LCD_D5 at P2_3_bit;
sbit LCD_D6 at P2_4_bit;
sbit LCD_D7 at P2_5_bit;
// End Lcd module connections

char txt1[] = "Embedded";
char txt2[] = "Projects";
char txt3[] = "Lcd 4 bit";
char txt4[] = "Tutorial";

char i;                              // Loop variable

void Move_Delay() {                  // Function used for text moving
  Delay_ms(500);                     // You can change the moving speed here
}

void main(){

  Lcd_Init();                        // Initialize Lcd

  Lcd_Cmd(_LCD_CLEAR);               // Clear display
  Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off
  Lcd_Out(1,6,txt3);                 // Write text in first row

  Lcd_Out(2,6,txt4);                 // Write text in second row
  Delay_ms(2000);
  Lcd_Cmd(_LCD_CLEAR);               // Clear display

  Lcd_Out(1,1,txt1);                 // Write text in first row
  Lcd_Out(2,5,txt2);                 // Write text in second row

  Delay_ms(2000);

  // Moving text
  for(i=0; i<4; i++) {               // Move text to the right 4 times
    Lcd_Cmd(_LCD_SHIFT_RIGHT);
    Move_Delay();
  }

  while(1) {                         // Endless loop
    for(i=0; i<8; i++) {             // Move text to the left 7 times
      Lcd_Cmd(_LCD_SHIFT_LEFT);
      Move_Delay();
    }

    for(i=0; i<8; i++) {             // Move text to the right 7 times
      Lcd_Cmd(_LCD_SHIFT_RIGHT);
      Move_Delay();
    }
  }
}



Circuit

USB to Serial Converter using AVR microcontrollers

AVR-CDC converts USB and RS-232C signals using the AVR micro- controller which has no on-chip USB interface. This technology is based on Object Deveopment's V-USB (Software-USB on AVR), and the CDC (Communication Device Class) protocol was extended over it. AVR-CDC enables PC to communicate with the USB device through virtual COM port.

The basic idea of using CDC protocol over Low-speed USB is based on Kyosuke Ishikawa's experiment in 2005. To make it stable and practical, Christian Starkjohann in Object Development helped me modifying his V-USB stack. Since three endpoints and the bulk transfer on low-speed device violates the USB standard, I added a tiny patch driver on Windows' USB stack.

Although this technology is quite experimental, it may be useful to interface your original system to PC easily. The circuit is very simple, but it requires a certain amount of skills to control. If you need practical or stable solutions, or you are not familiar with electronics nor installing drivers, use the dedicated chip from vendors like FTDI.

The back door to the low-speed bulk transfer is gradually closing on the newer OS. After enjoying this USB technology, switch to the HID protocol or to MCU having on-chip USB controller.

CDC-232

CDC-232 creates a virtual COM port on PC that doesn't have real RS- 232C port. It enables RS-232C communication (without control lines), after connecting the device and installing the driver.

Virtual COM Port over Software-USB

Usage

Write the program to AVR, build the circuit, and connect the device to PC's USB port. Install the driver on Windows. Access the device through generated virtual COM port from terminal software or your application. Control lines (DTR, DTS, RTS, CTS) are not used by the host application. Set the terminal software as "no flow-control".
Windows requests the driver installation again when connected to other USB port. Detect the previously installed driver automatically. Another COM number will be assigned. If you set serial number in AVR (rebuild with modified usbconfig.h), you can get the same COM port at any USB port. However, you cannot connect multiple CDC devices of the same serial number.
Before detaching the device, close the COM port in terminal software or in your application. Otherwise, you cannot connect to the device again because of the broken file handle. Restart the terminal software or your application then. Switch to the fast transfer mode using "lowcdc.vbs" to get the baudrate higher than 9600bps.

Loop-back test on ATtiny45 version

Schematics

These schematics are for ATtiny45/85, ATtiny2313/AT90S2313, and ATmega8/48/88/168. Their firmware are all ISP-programmable. The red LED drops the USB voltage from 5V to 3.3V, and provides to AVR. The current is about 10mA, and is not enough to drive other circuit. When connecting to other MCU, connect Gnd and connect TxD and RxD in crossing way. R4 limits the leak current when the MCU's Vcc is 5V. You can omit if the Vcc is equal. R5 protects the TxD pin when it shortened to Gnd. You can omit both R4 and R5 if you connect to the RS- 232C driver like MAX232. Use crystal oscillator. Although ceramic resonator works well in most cases, it becomes unstable if the frequency deviation is bigger. 

 CDC-232 for ATtiny45-20

ATtiny45/85 uses internal RC oscillator and PLL. It is calibrated by  USB signal when connected. UART is implemented by software. It is not enough for high speed data transfer. If the TxD and the RxD are inverted (rebuild with -DUART_INVERT option), you can directly connect to RS-232C line.     1200 - 4800bps, 8N1
 

CDC-232 for ATtiny2313-20               

ATtiny2313/AT90S2313 has 2KB program memory. Although the baudrate is configured automatically, some functions are omitted.   600 - 38400bps, 8N1

CDC-232 for ATmega8/48/88-20

ATmega8/48/88's internal UART is configured from the PC. The flow-control (RTS/CTS) is supported.
600 - 38400bps, data 7/8, parity N/E/O, stop 1/2

Schematics

 

 CDC-232 for ATtiny45-20

 

CDC-232 for ATtiny2313-20

 

CDC-232 for ATmega8/48/88-20

 

Driver and code click here for CDC home page

Interfacing Temperature Sensor – LM35 with AVR Microcontroller

By interfacing different types of sensors with our MCU we can sense the environment and take decisions, in this way we can create "smart" applications. There are wide variety of sensors available. In this tutorial we will learn about a popular sensor LM35 which is precision centigrade temperature sensor. It can be used to measure temperature with accuracy of 0.5 degree centigrade. We can interface it easily with AVR MCUs and can create thermometers, temperature controller, fire alarms etc.

LM35

LM35 by National Semiconductor is a popular and low cost temperature sensor. It is also easily available. It has three pins as follows.

The Vcc can be from 4V to 20V as specified by the datasheet. To use the sensor simply connect the Vcc to 5V ,GND to Gnd and the Out to one of the ADC (analog to digital converter channel). The output linearly varies with temperature. The output is

10MilliVolts per degree centigrade.

So if the output is 310 mV then temperature is 31 degree C. To make this project you should be familiar with the ADC of AVRs and also using seven segment displays. Please refer to following articles.

• Using the ADC of AVRs.
• Using Seven Segment Display.
• Using Seven Segment Display in Multiplexed Mode.

The resolution of AVRs ADC is 10bit and for reference voltage we are using 5V so the resolution in terms of voltage is

5/1024 = 5mV approx

So if ADCs result corresponds to 5mV i.e. if ADC reading is 10 it means

10 x 5mV = 50mV

You can get read the value of any ADC channel using the function

ReadADC(ch);

Where ch is channel number (0-5) in case of ATmega8. If you have connected the LM35's out put to ADC channel 0 then call

adc_value = ReadADC(0)

this will store the current ADC reading in variable adc_value. The data type of adc_value should be int as ADC value can range from 0-1023.

As we saw ADC results are in factor of 5mV and for 1 degree C the output of LM35 is 10mV, So 2 units of ADC = 1 degree.

So to get the temperature we divide the adc_value by to

temperature = adc_value/2;

Finally you can display this value in either the 7 segment displays by using the Print() function we developed in last tutorial or you can display it in LCD Module. To know how to display integer in 7 segment displays and LCD Modules see the articles.

• Multiplexed Seven Segment Display.
• Using LCD Modules with AVRs.

In this tutorial I have used three 7 segment displays to show the temperature. I have used the xBoard MINI - ATmega8 board to make the project. The complete program is given below.

Program (AVR GCC)

#include

#include

#include

#define SEVEN_SEGMENT_PORT PORTD

#define SEVEN_SEGMENT_DDR DDRD

uint8_t digits[3]; //Holds the digits for 3 displays

void SevenSegment(uint8_t n,uint8_t dp)

{

/*

This function writes a digits given by n to the display

the decimal point is displayed if dp=1

Note:

n must be less than 9

*/

if(n<10)

{

switch (n)

{

case 0:

SEVEN_SEGMENT_PORT=0b00000011;

break;

case 1:

SEVEN_SEGMENT_PORT=0b10011111;

break;

case 2:

SEVEN_SEGMENT_PORT=0b00100101;

break;

case 3:

SEVEN_SEGMENT_PORT=0b00001101;

break;

case 4:

SEVEN_SEGMENT_PORT=0b10011001;

break;

case 5:

SEVEN_SEGMENT_PORT=0b01001001;

break;

case 6:

SEVEN_SEGMENT_PORT=0b01000001;

break;

case 7:

SEVEN_SEGMENT_PORT=0b00011111;

break;

case 8:

SEVEN_SEGMENT_PORT=0b00000001;

break;

case 9:

SEVEN_SEGMENT_PORT=0b00001001;

break;

}

if(dp)

{

//if decimal point should be displayed

//make 0th bit Low

SEVEN_SEGMENT_PORT&=0b11111110;

}

}

else

{

//This symbol on display tells that n was greater than 9

//so display can't handle it

SEVEN_SEGMENT_PORT=0b11111101;

}

}

void Wait()

{

uint8_t i;

for(i=0;i<10;i++)

{

_delay_loop_2(0);

}

}

void Print(uint16_t num)

{

uint8_t i=0;

uint8_t j;

if(num>999) return;

while(num)

{

digits[i]=num%10;

i++;

num=num/10;

}

for(j=i;j<3;j++) digits[j]=0;

}

void InitADC()

{

ADMUX=(1<

ADCSRA=(1<

}

uint16_t ReadADC(uint8_t ch)

{

//Select ADC Channel ch must be 0-7

ch=ch&0b00000111;

ADMUX|=ch;

//Start Single conversion

ADCSRA|=(1<

//Wait for conversion to complete

while(!(ADCSRA & (1<

//Clear ADIF by writing one to it

ADCSRA|=(1<

return(ADC);

}

void main()

{

uint16_t adc_value;

uint8_t t;

// Prescaler = FCPU/1024

TCCR0|=(1<

//Enable Overflow Interrupt Enable

TIMSK|=(1<

//Initialize Counter

TCNT0=0;

//Port C[2,1,0] as out put

DDRB|=0b00000111;

PORTB=0b00000110;

//Port D

SEVEN_SEGMENT_DDR=0XFF;

//Turn off all segments

SEVEN_SEGMENT_PORT=0XFF;

//Enable Global Interrupts

sei();

//Enable ADC

InitADC();

//Infinite loop

while(1)

{

//Read ADC

adc_value=ReadADC(0);

//Convert to degree Centrigrade

t=adc_value/2;

//Print to display

Print(t);

//Wait some time

Wait();

}

}

ISR(TIMER0_OVF_vect)

{

static uint8_t i=0;

if(i==2)

{

i=0;

}

else

{

i++;

}

PORTB=~(1<

SevenSegment(digits[i],0);

}

8051 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 8051  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 8051  can understand. It also boosts the voltage of our 8051  to the needed +/-12V of the RS232 protocol so that a computer can understand our 8051  and vice versa. To get our 8051  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.

UART Library

The UART hardware module is available with a number of 8051 compliant MCUs. The mikroC PRO for 8051 UART Library provides comfortable work with the Asynchronous (full duplex) mode.

Library Routines

• UARTx_Init
• UARTx_Init_Advanced
• UARTx_Data_Ready
• UARTx_Read
• UARTx_Read_Text
• UARTx_Write
• UARTx_Write_Text
• UART_Set_Active

Notes:

• UART routines 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 2.
  Number of UART modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

Example: UART2_Init(9600); initializes UART 2 module at 9600 bps.

• Some 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).
• Some of the MCUs do not support UARTx_Init_Advanced routine. Please, refer to the appropriate datasheet.

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 frame size 8 bits 1 STOP bit parity mode disabled disabled automatic address recognition Parameters : baud_rate: requested baud rate Refer to the device datasheet for baud rates allowed for specific Fosc.
Requires	MCU with the UART module.
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 adv_setting);
Returns	Nothing.
Description	Configures and initializes UART module. Parameters : baud_rate sets the desired UART baud rate adv_setting: UART module configuration flags. Predefined library constants (see the table below) can be ORed to form appropriate configuration value. Description Predefined library const Parity constants: Parity mode disabled _UART_NOPARITY Even parity _UART_EVENPARITY Odd parity _UART_ODDPARITY Mark parity _UART_MARKPARITY Space parity _UART_SPACEPARITY Stop bit constants: 1 stop bit _UART_ONE_STOPBIT 2 stop bits _UART_TWO_STOPBITS Output mode constants: Output set as quasi-bidirectional (8051) _UART_OUTPUT_8051 Output set as push-pull _UART_OUTPUT_PUSH_PULL Output set as open-drain _UART_OUTPUT_OPEN_DRAIN Notes: Some MCUs do not support advanced configuration of the UART module. Please consult appropriate datasheet. Advanced parity and stop bit settings are supported by some Silicon Laboratories MCU's, while output settings by some ATMEL MCU's. Please, consult appropriate datasheet before using UARTx_Init_Advanced routine.
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	MCU with the UART module. The UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	char receive; ... // read data if ready if (UART1_Data_Ready())   receive = UART1_Read();

UARTx_Read

Prototype	char UARTx_Read();
Returns	Returns the received byte.
Description	The function receives a byte via UART. Use the UARTx_Data_Ready function to test if data is ready first.
Requires	MCU with the UART module. The UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	char receive; ... // read data if ready if (UART1_Data_Ready())   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 and UARTx_Init_Advanced routines.
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 and UARTx_Init_Advanced routines.
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 and UARTx_Init_Advanced routines.
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)())
Returns	Nothing.
Description	Sets active UART module which will be used by the UART library routines. Parameters : read_ptr: UARTx_Read handler write_ptr: UARTx_Write handler ready_ptr: UARTx_Data_Ready handler
Requires	Routine is available only for MCUs with two UART modules. Used UART module must be initialized before using this routine. See UARTx_Init and UARTx_Init_Advanced routines.
Example	// Activate UART2 module UART_Set_Active(&UART2_Read, &UART2_Write, &UART2_Data_Ready);

Library Example

This example demonstrates simple data exchange via UART. If MCU is connected to the PC, you can test the example from the mikroC PRO for 8051 USART Terminal.

char uart_rd;

void main() {

 

  UART1_Init(4800);               // Initialize UART module at 4800 bps

  Delay_ms(100);                  // Wait for UART module to stabilize

 

  UART1_Write_Text("Start");

  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

    }

  }

}

HW Connection