Programming PIC16F877A Using XC8

 

Introduction

PIC16F877A was a popular 8-bit microcontroller for university students and hobbyists. It still useful for novice programmers learning to program microcontroller.

This device has digital I/O, analog input, Timer, PWM output, Communication, and other features.

PIC16F87XA devices Table

I select PIC16F877A-I/P in DIP package that ease of prototyping.

PIC16F877A 40-Pin DIP Package Pin Diagram

 

PIC16F877A 40 pins DIP

Architecture

It’s designed using Harvard architecture, separating between program and data memory. CPU fetches both data and program memory concurrently. Its pipe-lining technique make instruction execution archive at one CPU cycle, but it excepts some instructions that require more than one cycle.

Memory

Its program counter is 13-bit wide. Instruction length is 14-bit (called one word). It can address program memory of 8K x 14 program space. Reset vector locate at address 0000h. It has only one interrupt vector which locate at address 0004h.

PIC16F877A memory map and stack

Stack used for calling and returning sub routine. It’s 8 levels, allowing up to 8 nested sub routine calling. Nested calling more than this value, making program unpredictable.

Coding PIC16F877A

Assembly language is core programming for microcontroller. It’s preferred for most of university program. It’s essential for programmer to understand overall operation of microcontroller before allowing to program in Assembly language.

Assembly language is free offered by device’s manufacturer. Programming made from this language composes of a lot of lines. It consumes a very long time to complete a program using this language. Updating and modifying program is very hard.

However microcontroller program written in Assembly language is very effective in program memory. Program execution is very fast.

Modern embedded C compilers for PIC microcontroller is very popular now. Even small 8-bit microcontroller implemented using C regardless of its program memory space – for example PIC microcontroller with 1KB of program memory. I see only a few of C compilers in market,

• MikroC
• CCS PICC
• XC8

XC8 integrated in MPLABX IDE from Microchip Technology. It has a free version without limitation.

Getting Started With C Using XC8

Toggling digital I/O is a good getting-started section for most of microcontroller new learner. It allow us to test its normal operation.

Hardware

PIC16F877A supplies at +5V DC with its clocking input of 20MHz, from external crystal oscillator. Port C connects to 8 LED outputs via a resistor network.

Schematic Diagram

In Proteus, power supply pins are hidden but they internally wired by this simulator program.

C Programmer

This getting started program made of a little lines of code. Device configuration section seem very long due XC8 compiler directives. Port C toggles its output with a delay of one second.

/*
 * Blinking PORTC of PIC16F877A
 * using XC8 in MPLABX IDE
 */
#include <xc.h>
 
// CONFIG
#pragma config FOSC = HS
// Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF
// Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF
// Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = ON
// Brown-out Reset Enable bit (BOR enabled)
#pragma config LVP = OFF
// Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit
//(RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = OFF
// Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF
// Flash Program Memory Write Enable bits (Write protection off;
//all program memory may be written to by EECON control)
#pragma config CP = OFF
// Flash Program Memory Code Protection bit (Code protection off)
 
/*Clocking Parameter for Delay Function*/
#define _XTAL_FREQ  20000000
 
void main(void){
    /*Clear Port C*/
    PORTC=0x00;
    /*Set Port C To Output*/
    TRISC=0x00;
    while(1){
        PORTC=0x00;
        __delay_ms(1000);
        PORTC=0xFF;
        __delay_ms(1000);
    }
}

 This program consumes about 1% of memory resource.

Statistic in MPLABX IDE dashboard

Click here to download this example package.

AT89C52 Character LCD and Keypad Interfacing Using C

We have seen about 4x4 matrix keypad and character LCD interfacing with AT89C52 in previous post. Now let put these two external devices to work together with this controller.

In this programming example, I use a 4x4 matrix keypad and a HD44780-based character LCD, controlled by AT89C52. The two lines character LCD shows the received the controller received from keypad.

This keypad has 16 value ranging from 1 to 9, and from A to F in ASCII format.

Circuit diagram

Source code is written in C, using Keil uVision IDE.

/*
AT89C52 8051 Interface to Character LCD
and Matrix Keypad Programming in C using Keil
*/
 
#include <REG52.h>
 
#define DPORT				P2
#define KEY_PORT    P1
 
/*Keypad rows setting*/
sbit 	row0=P1^4;
sbit 	row1=P1^5;
sbit	row2=P1^6;
sbit	row3=P1^7;
 
/*
RS bit 0
RW to  GND
EN bit 1
*/
 
void	lcdInit();
void	lcdCmd(unsigned char cmd);
void	lcdDat(unsigned char dat);
void	lcdStr(unsigned char *str);
void	lcdXY(unsigned char x, unsigned char y);
void 	_delay_us(unsigned int t);
void 	_delay_ms(unsigned int T);
void	lcdClear();
 
/**********KeyPad*************/
unsigned char getKey();
 
unsigned char keypad[4][4]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
unsigned char	output[4]={0xFE,0xFD,0xFB,0xF7};
unsigned row,col,key_value;
bit    found=0;
 
unsigned char temp;
 
int main(void)
{	
	  unsigned char keyVal,pressCnt=0;
	  unsigned char keyStr[16];
	  unsigned int i=0;
		unsigned char keyChar[16]={'7','8','9','F','4','5','6','E','1','2','3','D','A','0','B','C'};
	  lcdInit();
		KEY_PORT=0xF0;
	  lcdXY(1,1);
	  P3=0x00;
		lcdStr("Enter Key Value:");
		lcdXY(1,2);
    while(1)
    {
			keyVal=getKey();
			if(found==1){
				lcdDat(keyChar[keyVal]);
				found=0;
				pressCnt++;
				for(i=0;i<32800;i++);
			}
			if(pressCnt>16){
				pressCnt=0;
				for(i=0;i<50000;i++);
				lcdClear();
				lcdXY(1,1);
				lcdStr("Enter Key Value:");
				lcdXY(1,2);
			}
    }
 
}
 
 
void lcdCmd(unsigned char cmd){
	temp=0x02;
	DPORT=temp|(cmd&0xF0);
	_delay_us(10);
	temp=0x00;
	DPORT=temp|(cmd&0xF0);
	_delay_us(100);
 
	temp=0x02;
	DPORT=temp|(cmd<<4);
	_delay_us(10);
	temp=0x00;
	DPORT=temp|(cmd<<4);
}
 
void lcdDat(unsigned char dat){
	temp=0x03;
	DPORT=temp|(dat&0xF0);
	_delay_us(10);
	temp=0x01;
	DPORT=temp|(dat&0xF0);
	_delay_us(100);
 
	temp=0x03;
	DPORT=temp|(dat<<4);
	_delay_us(10);
	temp=0x01;
	DPORT=temp|(dat<<4);
}
 
void lcdInit(){
 
	DPORT=0x00;
	_delay_ms(2);
	lcdCmd(0x33);
	_delay_us(100);
	lcdCmd(0x32);
	_delay_us(100);
	/*2-Lines Mode 4-Bit*/
	lcdCmd(0x28);
	_delay_us(100);
	/*Display On Cursor Blink*/
	lcdCmd(0x0F);
	_delay_us(100);
	/*Clear Screen*/
	lcdCmd(0x01);
	_delay_ms(2);
	/*Cursor Increment*/
	lcdCmd(0x06);
	_delay_us(100);
}
 
void lcdStr(unsigned char *str){
	unsigned char i=0;
	while(str[i]!=0){
		lcdDat(str[i]);
		i++;
	}
}
 
void lcdXY(unsigned char x, unsigned char y){
	/*20x4 LCD Address */
	//unsigned char tbe[]={0x80,0xC0,0x94,0xD4};	
	/*16x2 LCD Address*/
	unsigned char tbe[]={0x80,0xC0};
	lcdCmd(tbe[y-1]+x-1);
	_delay_us(100);
}
 
void _delay_us(unsigned int a){
	unsigned int i,j;
	for(i=0;i<5;i++)
		for(j=0;j<a;j++);
}
 
void _delay_ms(unsigned int b){
	unsigned int i;
	for(i=0;i<b;i++)	_delay_us(1000);
}
 
void lcdClear(){
	lcdCmd(0x01);
	_delay_us(10);
}
 
/*4x4 Matrix KeyPad Routine*/
unsigned char getKey(){
 
    static unsigned char i=0;
 
		for (i=0;i<4;i++){
            KEY_PORT=output[i];
            if((KEY_PORT&0xF0)!=0xF0)  
            {   col=i;
                found=1;
                break;
            }
        }
 
        if(row0==0) row=0;
        else if (row1==0)   row=1;
        else if (row2==0)   row=2;
        else if (row3==0)    row=3;
 
        if(found==1)
					return key_value=keypad[row][col];   
				found=0;
}
 

Click here to download source file.