PIC16F84A Software UART Programming Example Using XC8

Overview

For a small embedded controller, UART(Universal Asynchronous Receiver-Transmitter) is a communication module inside the controller that send and receive serial data to or from its peripheral device. Its data format and speed are configurable.

 

A Conventional UART Module

This communication module is commonly come with many popular micro-controller such as, AT89S52, ATMega32, or PIC16F877A, etc.

A Simple Connection Between Two Devices

Each devices have their own supply voltage and clock generator. The connection requires only Tx/Rx pair and a common ground (GND). In some case it requires only a Tx either an Rx and a common ground signal.

Connecting device may use one of there three communication modes:

1. simplex
2. full duplex
3. haft duplex

A UART frame consists of 5 elements:

• Idle (logic high)
• Start bit (logic low)
• Data bits
• Parity bit
• Stop bit (logic high)

In most common settings of 8 data bits, on parity and 1 stop bit (aka 8N1).

UART Signal

Signal could be transmitter or receiver signal. BCLK is a clock source inside each devices.

Baud or bits per second (bit/s) is the number of bits that processed per unit of time. Each data bits duration could be calculated a:

Ts = 1 / fs

 Where,

• Ts : symbol duration
• fs  : Baud or pits per second

For example, we select a 9600 baud. Hence, 

Ts = 1 / 9600 = 0.000104 second = 104 microseconds.

So each data bits (1's or 0's) must be around 104 microseconds.

For any controller that come with UART module, the programmer can set its baud by hardware setting and calculation.

However some controller doesn't have UART module inside (e.g PIC16F84A). So we can emulate UART by bit banging GPIO pins in software (Assembly or C language).

PIC16F84A UART Bit Banging 

Bit banging of serial communication could be done easily using software routine in most of programming languages. It requires additional program space. The programmer can select any microcontroller digital I/O pin to transmit or receiving data bits. Data processing takes a little period to send and receive serial data. However data errors may occur in some situation.

Some C compiler such as MikroC, CCS PICC have a software driver for bit banging. But we write our own function to process this task.

In this example, I select a 9600 baud, no parity and one stop bit (8N1). Start bit triggers from a high to low transition. Logic low signal should be delayed for around 100 microseconds. Each data bits should be sampled at the middle of data bits duration. The program samples receiving data bits around 60 microseconds. 

Sample Data Bits For A 9600 Baud

The sample time begin after the middle of each data bits.

The program listens to serial data start of transmission. Whenever the high to low transition start the serial data reception will process.

Received ASCII Data Showed On Port B

Whenever serial data received the controller will echo it to serial terminal. Serial terminal settings is 8N1(8-bit No Parity One Stop Bit). Serial data is in ASCII format. This ASCII character will show on Port B. Whenever a 0 ASCII character received it will toggle RA2. A 1 ASCII character will toggle RA3.

 
/*
 for 9600 baud rate
 * 1/9600 = 104uS per bit
 * we can use 102.5uS per bit 
 */
 
#include <xc.h>
 
// PIC16F84A Configuration Bit Settings
 
// CONFIG
#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (Power-up Timer is disabled)
#pragma config CP = OFF         // Code Protection bit (Code protection disabled)
 
#define _XTAL_FREQ  4000000
#define TX  RA0
#define RX  RA1
 
void sendChar(char data){
    TX=0;
    __delay_us(100);
    for(int i=0;i<8;i++){
        TX=data&(1<<0);
        data>>=1;
        __delay_us(75);
    }
    TX=1;
    __delay_us(100);
}
 
char myChar=0,temp=0;
void receiveChar(void){
    if(RX==0){
        __delay_us(100);     
 
        for(char i=0;i<8;i++){
            __delay_us(60);
            if(RX==1) myChar|=(1<<i);
            else myChar&=~(1<<i);
        }
        __delay_us(50);
    }
}
void sendText(char *text){
    while(*text) sendChar(*text++);
}
 
void softUARTInit(void){
    PORTA=0x00;
    TRISA=0x02;
    PORTB=0;
    TRISB=0;
    TX=1;
}
 
void main(){
 
    softUARTInit();
    sendText("HELLO WORLD!\r\n");
    while(1){
        receiveChar();
        if(myChar!=0){
            PORTB=myChar;
            sendChar(myChar);
            //sendText("\r\n");
            if(myChar=='0') { RA2^=1; sendText(" Toggle RA2.\r\n");}
            if(myChar=='1') { RA3^=1; sendText(" Toggle RA3.\r\n");}
            myChar=0;
        }
    }
}
 

Click here to download this example.

PIC16F84A UART Bit Banging And Character LCD Example

A character LCD is very easy to control using a small micro-controller. Now I will send ASCII characters over UART terminal to the micro-controller. Those character will show on a 20x4 character LCD. 

Program Simulation

This example program consume half of program memory.

/*
 Software UART LCD Example 1
 */
#include <xc.h>
#include "LCD4Bits.h"
 
// PIC16F84A Configuration Bit Settings
 
// CONFIG
#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (Power-up Timer is disabled)
#pragma config CP = OFF         // Code Protection bit (Code protection disabled)
 
#define _XTAL_FREQ  4000000
#define TX  RA0
#define RX  RA1
 
void sendChar(char data){
    TX=0;
    __delay_us(100);
    for(int i=0;i<8;i++){
        TX=data&(1<<0);
        data>>=1;
        __delay_us(75);
    }
    TX=1;
    __delay_us(100);
}
 
char myChar=0,temp=0;
void receiveChar(void){
    if(RX==0){
        __delay_us(100);
        for(char i=0;i<8;i++){
            __delay_us(60);
            if(RX==1) myChar|=(1<<i);
            else myChar&=~(1<<i);
        }
        __delay_us(100);
    }
}
void sendText(char *text){
    while(*text) sendChar(*text++);
}
 
void softUARTInit(void){
    PORTA=0x00;
    TRISA=0x02;
    PORTB=0;
    TRISB=0;
    TX=1;
}
 
void main(){
    uint8_t line=1,charNum=1;
    softUARTInit();
    lcdInit();
    sendText("PIC16F84A Software UART And Character LCD\r\n");
    lcdString("PIC16F84A 20x4 LCD");
    lcdXY(1,2);
    lcdString("Software Delay UART");
    lcdXY(1,3);
    lcdString("Programming Example");
    lcdXY(1,4);
    lcdString("MPLABX IDE And XC8");
    __delay_ms(2000);
    lcdClear();
 
    while(1){
        receiveChar();
        if(myChar!=0&&myChar!=0x08){
            sendChar(myChar);
            if(myChar=='0') { RA2^=1; sendText(" Toggle RA2.\r\n");}
            if(myChar=='1') { RA3^=1; sendText(" Toggle RA3.\r\n");}
            if(myChar==0x0D) {
                line+=1;
                lcdXY(1,line);
                charNum=1;
            }else{
                lcdData(myChar);
            }
            charNum+=1;
            if(charNum>20) {charNum=1; line+=1; lcdXY(charNum,line);}
            if(line>4){line=1;lcdXY(charNum,line);}
            myChar=0;
        }
    }
}

Click here to download its source file.

PIC16F84A DHT11 Temperature And Humidity Sensor And Character LCD Interfacing Using XC8

Overview

The DHT11 temperature and humidity sensor features a temperature and humidity sensor
complex with a calibrated digital signal output. By using the exclusive digital-signal-acquisition
technique and temperature and humidity sensing technology, it ensures high reliability and
excellent long-term stability. This sensor includes a resistive-type humidity measurement
component and an NTC temperature measurement component, and connects to a high performance 8-bit micro-controller, offering excellent quality, fast response, anti-interference
ability and cost-effectiveness.

DHT11 Humidity & Temperature
Sensor

Parameters

Relative Humidity
Resolution：             16Bit
Repeatability：         ±1%RH
Accuracy：               25℃ ±5%RH
Interchangeability：  Fully interchangeable
Response time：       1/e (63%)25℃ 6s
                                1m/s Air 6s
Hysteresis：             <±0.3%RH
Long-term stability： <±0.5%RH/yr

Temperature
Resolution：             16Bit
Repeatability：         ±1℃
Accuracy：               25℃ ±2℃
Response time：       1/e (63%) 10S

Electrical Characteristics
Power supply：         DC 3.3～ 5.5V
Supply current：       Measure 0.3mA Standby 60μA
Sampling period：     Secondary Greater than 2 seconds 

Micro-controller Interfacing

This sensor uses only one bidirectional pin to accept a start signal from the micro-controller. It will send back its serial data with 40 bits length to the micro-controller. 

Typical Application

A 5 kill Ohms pull up resistor is usable for a connection length below 20 meters. For the connection over 20 meters, choose a suitable value of pull up resistor. Its power supply is between 3 to 5.5V DC. For a stable operation at long range, use a an appropriate filtering capacitor.

Bi-directional Serial Communication

The micro-controller output pin is in normal high logic standby mode. It must issue a start command by putting its data pin to low level around 18 milliseconds, and then the data pin must be pull up to high logic for 30 microseconds. DHT11 will send a low to high logic respond signal to micro-controller.

Overall Communication Process

Micro-controller's data pin must be assigned to input direction to accept serial data from DHT11 sensor.

MCU sends out start signal and DHT11 responses

The response signal from DHT11 is a low (around 80 microseconds) to high logic level (around 80 microseconds).

After this response signal, the sensor will send its serial data with 40 bits length. A low logic level of 50 microseconds indicates a start of each data bits. After that is a high logic level with two distinct duration that identify between 0's and 1's logic value of each data bits.

Data"0" Indication

Logic high with a duration around 25 to 28 microseconds indicates a 0's data bit.
 

Data "1" Indication

Logic high with a duration around microseconds indicates a 1's data bit.

logic 0's and 1's values

To sample this signal, the micro-controller should use a timer or a simple delay function to detect the duration of high logic signal.

Data Timing Diagram

After the transmission of its 40 bits data, a low end time with a duration of 50 microseconds indicate the end of transmission. It will turn to logic high due to a pull up resistor.

Data Format 

Its total data is 40 bits wide that include these data bytes,

1. byte 0 - decimal humidity value
2. byte 1 - empty humidity value
3. byte 2 - decimal temperature value
4. byte 4 - empty temperature value
5. byte 5 - parity.

This sensor has only decimal humidity and temperature value. Its empty value data bytes are ignore.

It parity byte is useful for error checking. We can calculate as follow,

parity(byte 5) = byte 0 + byte 1 + byte 2 + byte 3

If this calculation is not verified then the micro-controller must read this sensor data again. For example, the sensor is read 53RH (humidity) and 24 degree Celsius (temperature) with a parity of 77 (in binary 0100 1101). We can calculate it as below,

Parity Check

That is,

0011 0101 + 0000 0000 + 0001 1000 + 0000 0000 = 0100 1101

This 40-bit data is correct. So we can use it.

Micro-controller Interfacing And Programming

A simple 8-bit micro-controller could command and decode the serial data from this sensor easily. A 8051 micro-controller could interface with this sensor with a simple display output. The firmware require a little space of micro-controller program memory space.

Program Simulation

A simple 8-bit PIC micro-controller is suitable for this task, due to a little amount of I/O, small footprint, and a reasonable amount of RAM and ROM space. I use a PIC16F84A micro-controller. This controller has only digital I/O, without analog I/O and communication module. We don't need these peripheral here. I use Proteus VSM to simulate this sample program because this micro-controller was burn out a long time ago. I will not buy it more. Currently there are a lot of newly designed controllers from Microchip Technology with rich peripherals and low cost.

Sample Serial Data

We can see its serial data transmission over the virtual DSO screen of the simulator. To check this serial signal without a micro-controller we can use a switch instead with an oscilloscope. We just press the switch to make low signal and the release it. The output serial data of this sensor will be sent out.

/*
 * PIC16F84A DHT11 Temperature and Humidity Sensor Interfacing
 * With HD44780 Character LCD
 * MPLABX IDE v1.51
 * XC8 v2.36
 */
 
#include <xc.h>
#include "LCD4Bits.h"
 
#define _XTAL_FREQ  4000000UL
#define DATA_PIN    RA4
#define DATA_DIR    TRISA4
 
uint8_t data[5];
void readDHT11(void){
    for(uint8_t i=0;i<5;i++) data[i]=0;  
    DATA_DIR=0;
    DATA_PIN=1;
    __delay_ms(10);
    DATA_PIN=0;
    __delay_ms(18);
    DATA_PIN=1;
    __delay_us(30);
    DATA_PIN=0;
    DATA_DIR=1;
    __delay_us(10);
    while(DATA_PIN==0);
    __delay_us(10);
    while(DATA_PIN==1);
    __delay_us(10);
 
    //Start of Transmission  
    for(uint8_t i=0;i<5;i++) {
        for(uint8_t j=0;j<8;j++){
        __delay_us(5);
        while(DATA_PIN==0);
        __delay_us(50);
        if(DATA_PIN==1) { data[i]|=(1<<7-j);}
    }
       __delay_us(10);
    }
    /*CRC Calculation - the last byte data[4] is check sum*/
    uint8_t crc = data[0]+data[1]+data[2]+data[3];
    if(crc!=data[4]) {for(uint8_t i=0;i<4;i++) data[i]=0; return;}
    __delay_us(10);
}
int main(void){
    PORTA=0;
    TRISA=0;
 
    PORTB=0;
    TRISB=0;
 
    lcdInit();
 
    lcdXY(1,1); lcdString("Humidity   : ");
    lcdXY(1,2); lcdString("Temperature: ");
 
    while(1){
         readDHT11();
 
         lcdXY(13,1);
        /*Humidity is below 90RH*/
        if(data[0]>=10) lcdData(48+(data[0]%100)/10);
        lcdData(48+(data[0]%10));
        lcdData('R');
        lcdData('H');
 
        /*Temperature is below 50 degree Celsius*/
        lcdXY(13,2);
        if(data[2]>=10) lcdData(48+data[2]/10);
        lcdData(48+(data[2]%10));
        lcdData(223);
        lcdData('C');
        __delay_ms(500);              
    }
    return 0;
}

Built program uses only 50% of program memory. We can add a few switches and an output relay or transistor to set the a temperature condition with an output device (an AC or DC fan).

MPLABX IDE Build Output

The MPLABX IDE release is v1.51 (2012). I use the XC8 v2.36. It's a free version without code optimization and technical support. Click here to download its source file.