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

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 used to run and control them are in the form of functions stored in the One_Wire library. There are three functions in total:

• Ow_Reset is used for reseting sensor;
• Ow_Read is used for receiving data from sensor; and
• Ow_Write is used for sending commands to sensor.

Concretely, you don’t have to study documentation provided by the manufacturer in order to use this sensor. It is sufficient to copy some of these functions in the program.

OneWire Library

The OneWire library provides routines for communication via the Dallas OneWire protocol, e.g. with DS18x20 digital thermometer. OneWire is a Master/Slave protocol, and all communication cabling required is a single wire. OneWire enabled devices should have open collector drivers (with single pull-up resistor) on the shared data line.

Slave devices on the OneWire bus can even get their power supply from data line. For detailed schematic see device datasheet.

Some basic characteristics of this protocol are:

• single master system,
• low cost,
• low transfer rates (up to 16 kbps),
• fairly long distances (up to 300 meters),
• small data transfer packages.

Each OneWire device has also a unique 64-bit registration number (8-bit device type, 48-bit serial number and 8-bit CRC), so multiple slaves can co-exist on the same bus.

Note: Oscillator frequency Fosc needs to be at least 8MHz in order to use the routines with Dallas digital thermometers.

External dependencies of OneWire Library

This variable must be defined in any project that is using OneWire Library:	Description:	Example :
extern sfr sbit bdata OW_Bit;	OneWire line.	sbit OW_Bit at P2_7_bit;

Library Routines

• Ow_Reset
• Ow_Read
• Ow_Write

Ow_Reset

Prototype	unsigned short Ow_Reset();
Returns	0 if the device is present 1 if the device is not present
Description	Issues OneWire reset signal for DS18x20. Parameters : None.
Requires	Devices compliant with the Dallas OneWire protocol. Global variable OW_Bit must be defined before using this function.
Example	// Issue Reset signal on One-Wire Bus Ow_Reset();

Ow_Read

Prototype	unsigned short Ow_Read();
Returns	Data read from an external device over the OneWire bus.
Description	Reads one byte of data via the OneWire bus.
Requires	Devices compliant with the Dallas OneWire protocol. Global variable OW_Bit must be defined before using this function.
Example	// Read a byte from the One-Wire Bus unsigned short read_data; ... read_data = Ow_Read();

Ow_Write

Prototype	void Ow_Write(char par);
Returns	Nothing.
Description	Writes one byte of data via the OneWire bus. Parameters : par: data to be written
Requires	Devices compliant with the Dallas OneWire protocol. Global variable OW_Bit must be defined before using this function.
Example	// Send a byte to the One-Wire Bus Ow_Write(0xCC);

Circuit

Code

This example reads the temperature using DS18x20 connected to pin P1.2. After reset, MCU obtains temperature from the sensor and prints it on the Lcd. Make sure to pull-up P1.2 line and to turn off the P1 leds.

// 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

// OneWire pinout

sbit OW_Bit at P1_2_bit;

// end OneWire definition

//  Set TEMP_RESOLUTION to the corresponding resolution of used DS18x20 sensor:

//  18S20: 9  (default setting; can be 9,10,11,or 12)

//  18B20: 12

const unsigned short TEMP_RESOLUTION = 9;

char *text = "000.0000";

unsigned temp;

void Display_Temperature(unsigned int temp2write) {

  const unsigned short RES_SHIFT = TEMP_RESOLUTION - 8;

  char temp_whole;

  unsigned int temp_fraction;

  // check if temperature is negative

  if (temp2write & 0x8000) {

    text[0] = '-';

    temp2write = ~temp2write + 1;

  }

  // extract temp_whole

  temp_whole = temp2write >> RES_SHIFT ;

  // convert temp_whole to characters

  if (temp_whole/100)

     text[0] = temp_whole/100  + 48;

  else

     text[0] = '0';

  text[1] = (temp_whole/10)%10 + 48;             // Extract tens digit

  text[2] =  temp_whole%10     + 48;             // Extract ones digit

  // extract temp_fraction and convert it to unsigned int

  temp_fraction  = temp2write << (4-RES_SHIFT);

  temp_fraction &= 0x000F;

  temp_fraction *= 625;

  // convert temp_fraction to characters

  text[4] =  temp_fraction/1000    + 48;         // Extract thousands digit

  text[5] = (temp_fraction/100)%10 + 48;         // Extract hundreds digit

  text[6] = (temp_fraction/10)%10  + 48;         // Extract tens digit

  text[7] =  temp_fraction%10      + 48;         // Extract ones digit

  // print temperature on LCD

  Lcd_Out(2, 5, text);

}

void main() {

  Lcd_Init();                                    // Initialize LCD

  Lcd_Cmd(_LCD_CLEAR);                           // Clear LCD

  Lcd_Cmd(_LCD_CURSOR_OFF);                      // Turn cursor off

  Lcd_Out(1, 1, " Temperature:   ");

  // Print degree character, 'C' for Centigrades

  Lcd_Chr(2,13,223);  // different LCD displays have different char code for degree

                      // if you see greek alpha letter try typing 178 instead of 223

  Lcd_Chr(2,14,'C');

  //--- main loop

  do {

    //--- perform temperature reading

    Ow_Reset();                                  // Onewire reset signal

    Ow_Write(0xCC);                              // Issue command SKIP_ROM

    Ow_Write(0x44);                              // Issue command CONVERT_T

    Delay_us(120);

    Ow_Reset();

    Ow_Write(0xCC);                              // Issue command SKIP_ROM

    Ow_Write(0xBE);                              // Issue command READ_SCRATCHPAD

    temp =  Ow_Read();

    temp = (Ow_Read() << 8) + temp;

    //--- Format and display result on Lcd

    Display_Temperature(temp);

    Delay_ms(500);

  } while (1);

}

.