Usando display de LCD no modo 4 bits com o XC8

Aqui vou demonstrar como usar um display de 2 linhas 16 caracteres usando o Mplab XC8, para colocar a frase na linha 1 basta inserir o carácter "\n" ena linha dois o carácter "\r" antes da mensagem desejada.Uma vantagem desta configuração é a possibilidade de escolher qualquer port e pino do microcontrolador por meio do"#define" dos bits, livrando a necessidade de ter um port especifico pra isso.

O Código fonte:

/*
 *                          USANDO DISPLAY DE LCD NO MODO 4BITS
 *
 * Compilador :      MPlabXC8
 * Microcontrolador: 18F13K22
 * Autor:            Aguivone
 * Versão:           1
 * Data de criação:  29 de agosto de 2014.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h> //para usar funçoes de string deve se adicionar este header
#include <xc.h>
#define _XTAL_FREQ 16000000//usado para rotinas de  delays
/*******************************configuraçôes do pic ****************************************************/

// CONFIG1H
#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
#pragma config PLLEN = OFF      // 4 X PLL Enable bit (PLL is under software control)
#pragma config PCLKEN = ON      // Primary Clock Enable bit (Primary clock enabled)
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable (Fail-Safe Clock Monitor disabled)
#pragma config IESO = OFF       // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)

// CONFIG2L
#pragma config PWRTEN = OFF     // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bits (Brown-out Reset disabled in hardware and software)
#pragma config BORV = 19        // Brown Out Reset Voltage bits (VBOR set to 1.9 V nominal)

// CONFIG2H
#pragma config WDTEN = OFF      // Watchdog Timer Enable bit (WDT is controlled by SWDTEN bit of the WDTCON register)
#pragma config WDTPS = 32768    // Watchdog Timer Postscale Select bits (1:32768)

// CONFIG3H
#pragma config HFOFST = ON      // HFINTOSC Fast Start-up bit (HFINTOSC starts clocking the CPU without waiting for the oscillator to stablize.)
#pragma config MCLRE = OFF      // MCLR Pin Enable bit (RA3 input pin enabled; MCLR disabled)

// CONFIG4L
#pragma config STVREN = ON      // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)
#pragma config LVP = ON         // Single-Supply ICSP Enable bit (Single-Supply ICSP enabled)
#pragma config BBSIZ = OFF      // Boot Block Size Select bit (512W boot block size)
#pragma config XINST = OFF      // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))

// CONFIG5L
#pragma config CP0 = OFF        // Code Protection bit (Block 0 not code-protected)
#pragma config CP1 = OFF        // Code Protection bit (Block 1 not code-protected)

// CONFIG5H
#pragma config CPB = OFF        // Boot Block Code Protection bit (Boot block not code-protected)
#pragma config CPD = OFF        // Data EEPROM Code Protection bit (Data EEPROM not code-protected)

// CONFIG6L
#pragma config WRT0 = OFF       // Write Protection bit (Block 0 not write-protected)
#pragma config WRT1 = OFF       // Write Protection bit (Block 1 not write-protected)

// CONFIG6H
#pragma config WRTC = OFF       // Configuration Register Write Protection bit (Configuration registers not write-protected)
#pragma config WRTB = OFF       // Boot Block Write Protection bit (Boot block not write-protected)
#pragma config WRTD = OFF       // Data EEPROM Write Protection bit (Data EEPROM not write-protected)

// CONFIG7L
#pragma config EBTR0 = OFF      // Table Read Protection bit (Block 0 not protected from table reads executed in other blocks)
#pragma config EBTR1 = OFF      // Table Read Protection bit (Block 1 not protected from table reads executed in other blocks)

// CONFIG7H
#pragma config EBTRB = OFF      // Boot Block Table Read Protection bit (Boot block not protected from table reads executed in other blocks)


//************************************************************************************/
//VARIAVEIS GLOBAIS
//************************************************************************************/
char gcCaracter;
bit  gbFlag_interrupcao = 0;


//o pino R/W é conectado ao terra pois não é feita nenhuma leitura no display
//configuração:
//
// pino da porta selecionada / pino display
//
// C4 = pino de D4 do display
// C5 = pino de D5 do display
// C6 = pino de D6 do display
// C7 = pino de D7 do display
//
// C1 = pino de RS do display
// C2 = pino de EN do display
//
/*************************** configuração dos pinos **************************************************/
 #define BIT_0  LATCbits.LATC4
 #define BIT_1  LATCbits.LATC5
 #define BIT_2  LATCbits.LATC6
 #define BIT_3  LATCbits.LATC7

 #define RS     LATCbits.LATC0
 #define EN     LATCbits.LATC1

#define _XTAL_FREQ 16000000//usado para rotinas de  delays


unsigned char valor_bit(char cDa,char cBit)
{
    unsigned char retorna = 0;
    if((cDa & cBit)>= 1)
    {
     retorna = 1;
    }
    return(retorna);
}

void porta_lcd(char cDado)//byte a ser enviado
{
       //envia os bytes mais altos
       BIT_0 = valor_bit(cDado,0X10);
       BIT_1 = valor_bit(cDado,0X20);
       BIT_2 = valor_bit(cDado,0X40);
       BIT_3 = valor_bit(cDado,0X80);
       EN = 1;
       __delay_ms(10);
       EN = 0;
       __delay_ms(15);
       //envia os bytes mais baixos
       RS = 0; //habilita comandos
       BIT_0 = valor_bit(cDado,0X01);
       BIT_1 = valor_bit(cDado,0X02);
       BIT_2 = valor_bit(cDado,0X04);
       BIT_3 = valor_bit(cDado,0X08);
       EN = 1;
       __delay_ms(10);
       EN = 0;
       __delay_ms(15);
}
void escreve_LCD(char cDado,int iVlr)//byte a ser enviado ,escreve caracter(0) ou comando(1)
{
    if(iVlr == 0)
       {
         RS = 0; //habilita comandos
       }
       else
       {
        RS = 1; //habilita dados
       }
       //envia os bytes mais altos
       BIT_0 = valor_bit(cDado,0X10);
       BIT_1 = valor_bit(cDado,0X20);
       BIT_2 = valor_bit(cDado,0X40);
       BIT_3 = valor_bit(cDado,0X80);
       EN = 1;
       __delay_us(30);//tempo estabilizar o pino
       EN = 0;
       __delay_us(30);//tempo estabilizar o pino
       //envia os bytes mais baixos
       BIT_0 = valor_bit(cDado,0X01);
       BIT_1 = valor_bit(cDado,0X02);
       BIT_2 = valor_bit(cDado,0X04);
       BIT_3 = valor_bit(cDado,0X08);
       EN = 1;
       __delay_us(30);//tempo estabilizar o pino
       EN = 0;
       __delay_us(30);
}

void inicializa_display(void)
{
       EN = 0;
       __delay_ms(15);//tempo para estabilizar a tensão e preparar o display
       porta_lcd(0X02);//nesse momento o display ainda está em modo 8bits solicita modo de 4 bits
       porta_lcd(0X28);//configura para usar modo 4bits,manda usar 2 linhas e matriza de caracter de 5X7.
       porta_lcd(0X01);//limpa display
       porta_lcd(0X06);//deslocamento do cursor para direita ,sem deslocamento de caracter automaticamente.
       porta_lcd(0X0C);//liga display ,cursor desligado e

}
void impri_lcd(const unsigned char *ucFrase)//  [17])
{
      unsigned int indice=0;
      unsigned int tamanho = strlen(ucFrase);
      while(indice<tamanho)
       {
            if(ucFrase[indice]=='\n')//linha 1
            {
              escreve_LCD(0X80,0);
                        }
            if(ucFrase[indice]=='\r')//linha2
            {
                          escreve_LCD(0XC0,0);
            }
            if((ucFrase[indice]!='\r') && (ucFrase[indice]!='\n') && (indice<18))//dados
                        {
                          escreve_LCD(ucFrase[indice],1);
            }
       indice++;
       }
}

//*******************************Rotina principal*********************************************/

void main(void)
{
    TRISC = 0x00;    
    inicializa_display();
    impri_lcd("\n__Teste de lcd  ");
    impri_lcd("\rTamanho max.16__");
for(;;)
    {}//loop infinito
}

A simulação: