Mini curso "Programación en XC8"

[KILLERJC]

Killerjc, tu caso es diferente.. Que programa usas? Que compilador? El MPLABX utilizando el XC8 debería de encontrarte la librería XLCD y sus funciones, están en la ruta que e puesto antes, si no están ahí es porque algo tienes mal instalado o estas utilizando un compilador o programa diferente.

Usaba MPLAB X + XC8 o XC16, pero hacia tiempo que no lo tocaba y limpie mi particion de linux borrandolo, y como me meti de lleno con un ARM no lo instale mas xD, pero C es C y los PICs son PICs, por lo que puedo saber de C y notar un error de programacion o puedo saber por que no funciona una cosa del PIC si esta mal configurada, pero cuando entro una libreria a la cual no tenia acceso al codigo se me complico, Intente buscarla por internet pero usaban otros nombres de funciones. Ahi se me complico mas xD Ya baje los archivos del MPLAB + XC8 por otra cosa que quiero hacer.

De todas formas uno podria linkear el .c no creo que exista necesidad de copiar y pegar el archivo. Al menos asi lo hago con el CSS de TI (basado en eclipse), si no lo encuentra te deberia dar un error el linker.

[illusionista_86]

Miquel_s, no hay de que, para eso estamos, hoy por ti, manyana por mi...

killerjc, no se si linkeando el .c funciona, pero como tu dices, deberia... por ahora he probado la forma que he comentado, y creo que es la que todos usan y es la que funciona.

[Miquel_S]

  Hola de nuevo, sigo con el lcd pero avanzando, tengo un error en el programa el cual desearía resolver antes de seguir y no doy con la solución.

Código: [Seleccionar]

/* DECLARACION DE FUNCIONES */
void Menu_Inicio(void);
void Menu_Principal(void);

/* FUNCIONES DE TEMPORIZACION */
void DelayFor18TCY(void)
{
    Delay10TCYx(2);
}
void DelayPORXLCD(void)
{
    Delay1KTCYx(15);
}
void DelayXLCD(void)
{
    Delay1KTCYx(2);
}

/* Envia comando al LCD */
void comandXLCD(unsigned char a)
{
    BusyXLCD();
    WriteCmdXLCD(a);
}

/* Ubica cursor en ( x = Posicion en linea , y = N de linea ) */
void gotoxyXLCD(unsigned char x, unsigned char y)
{
    unsigned char direccion;

    if(y != 1)
        direccion = 0x40;
    else
        direccion = 0;

    direccion += x-1;
    comandXLCD(0x80 | direccion);
}

void main(void)
{
    ADCON1 = 0b00001111;
    TRISA = 0x01;
    OpenXLCD(FOUR_BIT & LINES_5X7);     // Iniciamos Lcd
    comandXLCD(0x06);       // Nos aseguramos incremento de direccion, display fijo
    comandXLCD(0x0C);       // Encendemos Lcd
    Menu_Inicio();               // Llamamos a la funcion del menu de inicio.
    Menu_Principal();            // Llamamos a la funcion del menu principal.


    while(1)
    {
        if(PORTAbits.RA0){
            Menu_Principal();   // Retorna al menu principal
        }
        Delay1KTCYx(15);
    }
}

/* FUNCIONES PARA EL USO DEL MENU CICLICO */

/* Funcion menu de inicio */
void Menu_Inicio(void){
    putrsXLCD("Robot Minisumo");
    gotoxyXLCD(6,2);
    putrsXLCD("PANCHO");
    Delay10KTCYx(0);
}

/* Funcion menu principal */
void Menu_Principal(void){
    WriteCmdXLCD(CLEAR);
    gotoxyXLCD(2,1);
    putrsXLCD("MENU1");
    gotoxyXLCD(2,2);
    putrsXLCD("MENU2");
    gotoxyXLCD(10,1);
    putrsXLCD("MENU3");
    gotoxyXLCD(10,2);
    putrsXLCD("MENU4");
}

En la función Menu_Principal donde dice gotoxyXLCD(2,1); por mucho que cambie el valor de x siempre empieza en la posición 1 y no se porque ya que los demás si funcionan correctamente.

Gracias.

[Rseliman]

Hola amigos ...hace ya un tiempo que no me daba una vuelta ...habia dejado un poco de programar , ahora retornando quisiera pedirles un consejo ...

que mas me conviene usar con un pic cualquiera ...para enviar por internet una orden a una pagina de apretar un boton de ok ....no se si me explico ....o sea que apretando un boton conectado al pic , este mismo este conectado a la red , a esa pagina , y haga lo mismo que si fuese yo a la pagina con una pc  ingrese un numero y le de ok con el mouse o sea el dispositivo tendria un lcd para ver el numero que ingreso y un boton para darle ok ...obviamente conectado a la red logueado en ese servidor o pagina ...

Muchas gracias a todos !!!!

[leo_gladiador]

hola una consulta,como realizo pausas extensas(de horas) en xc8 ,es decir lo que quiero hacer es presionar un botón  y que cambie el estado de un pin  luego de un tiempo(1hora) determinado vuelva a cero.

Esta funcion no se si es eficiente  para realizar lo que quiero hacer

void pausa(unsigned int tiempo)
{
  unsigned int __tiempo;
  for (__tiempo = tiempo; __tiempo > 0; __tiempo--)
  {
    __delay_ms(1000);
  }
}


saludos 

[Miquel_S]

Hola leo_gladiator intenta no preguntar lo mismo en dos apartados diferentes.

Saludos!

[Thulsa Doom]

hola una consulta,como realizo pausas extensas(de horas) en xc8 ,es decir lo que quiero hacer es presionar un botón  y que cambie el estado de un pin  luego de un tiempo(1hora) determinado vuelva a cero.

Esta funcion no se si es eficiente  para realizar lo que quiero hacer

void pausa(unsigned int tiempo)
{
  unsigned int __tiempo;
  for (__tiempo = tiempo; __tiempo > 0; __tiempo--)
  {
    __delay_ms(1000);
  }

}

saludos 

Hola, mala idea emplear bucles para retardos, la razón es que el micro no podrá hacer nada más hasta que termine el bucle y si tienes un retardo de una hora pues el micro no podrá seguir ejecutando su programa hasta una hora después, con lo cual es inviable.
Para contar tiempos lo mejor es utilizar el timer 0 y una interrupción, hay una librería llamada Tick.c que se encuentra en las librerías TCP/IP de microchip que hace eso que tu buscas, es para C18 pero puede ser adaptada para XC8.
ya nos cuentas como te va

[Miquel_S]

Buenas tardes, tengo un pequeño problema con un programa para visualizar un mensaje en el LCD, me visualiza el mensaje pero al cabo de unos segundos desaparece y aparecen caracteres extraños desplazándose por la pantalla, he descartado problemas de hardware ya que en ASM el LCD funciona de forma correcta.

Código: C

1. /*
2.  * PIC: 18F2550
3.  * Compiler: XC8 v1.34
4.  * IDE: MPLABX v3.05
5.  */
6.  
7. #include <xc.h>
8. #include <stdio.h>
9. #include <stdlib.h>
10. #include <plib/xlcd.h>
11. #include <plib/delays.h>
12.  
13. #define _XTAL_FREQ 48000000     //Used by the XC8 delay_ms(x) macro
14.  
15. // CONFIG1L
16. #pragma config PLLDIV = 5       // PLL Prescaler Selection bits (Divide by 5 (20 MHz oscillator input))
17. #pragma config CPUDIV = OSC1_PLL2// System Clock Postscaler Selection bits ([Primary Oscillator Src: /1][96 MHz PLL Src: /2])
18. #pragma config USBDIV = 1       // USB Clock Selection bit (used in Full-Speed USB mode only; UCFG:FSEN = 1) (USB clock source comes directly from the primary oscillator block with no postscale)
19.  
20. // CONFIG1H
21. #pragma config FOSC = HSPLL_HS  // Oscillator Selection bits (HS oscillator, PLL enabled (HSPLL))
22. #pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)
23. #pragma config IESO = OFF       // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)
24.  
25. // CONFIG2L
26. #pragma config PWRT = OFF       // Power-up Timer Enable bit (PWRT disabled)
27. #pragma config BOR = OFF        // Brown-out Reset Enable bits (Brown-out Reset disabled in hardware and software)
28. #pragma config BORV = 3         // Brown-out Reset Voltage bits (Minimum setting)
29. #pragma config VREGEN = OFF     // USB Voltage Regulator Enable bit (USB voltage regulator disabled)
30.  
31. // CONFIG2H
32. #pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit))
33. #pragma config WDTPS = 32768    // Watchdog Timer Postscale Select bits (1:32768)
34.  
35. // CONFIG3H
36. #pragma config CCP2MX = ON      // CCP2 MUX bit (CCP2 input/output is multiplexed with RC1)
37. #pragma config PBADEN = OFF     // PORTB A/D Enable bit (PORTB<4:0> pins are configured as digital I/O on Reset)
38. #pragma config LPT1OSC = OFF    // Low-Power Timer 1 Oscillator Enable bit (Timer1 configured for higher power operation)
39. #pragma config MCLRE = ON       // MCLR Pin Enable bit (MCLR pin enabled; RE3 input pin disabled)
40.  
41. // CONFIG4L
42. #pragma config STVREN = ON      // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)
43. #pragma config LVP = OFF        // Single-Supply ICSP Enable bit (Single-Supply ICSP disabled)
44. #pragma config XINST = OFF      // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))
45.  
46. // CONFIG5L
47. #pragma config CP0 = OFF        // Code Protection bit (Block 0 (000800-001FFFh) is not code-protected)
48. #pragma config CP1 = OFF        // Code Protection bit (Block 1 (002000-003FFFh) is not code-protected)
49. #pragma config CP2 = OFF        // Code Protection bit (Block 2 (004000-005FFFh) is not code-protected)
50. #pragma config CP3 = OFF        // Code Protection bit (Block 3 (006000-007FFFh) is not code-protected)
51.  
52. // CONFIG5H
53. #pragma config CPB = OFF        // Boot Block Code Protection bit (Boot block (000000-0007FFh) is not code-protected)
54. #pragma config CPD = OFF        // Data EEPROM Code Protection bit (Data EEPROM is not code-protected)
55.  
56. // CONFIG6L
57. #pragma config WRT0 = OFF       // Write Protection bit (Block 0 (000800-001FFFh) is not write-protected)
58. #pragma config WRT1 = OFF       // Write Protection bit (Block 1 (002000-003FFFh) is not write-protected)
59. #pragma config WRT2 = OFF       // Write Protection bit (Block 2 (004000-005FFFh) is not write-protected)
60. #pragma config WRT3 = OFF       // Write Protection bit (Block 3 (006000-007FFFh) is not write-protected)
61.  
62. // CONFIG6H
63. #pragma config WRTC = OFF       // Configuration Register Write Protection bit (Configuration registers (300000-3000FFh) are not write-protected)
64. #pragma config WRTB = OFF       // Boot Block Write Protection bit (Boot block (000000-0007FFh) is not write-protected)
65. #pragma config WRTD = OFF       // Data EEPROM Write Protection bit (Data EEPROM is not write-protected)
66.  
67. // CONFIG7L
68. #pragma config EBTR0 = OFF      // Table Read Protection bit (Block 0 (000800-001FFFh) is not protected from table reads executed in other blocks)
69. #pragma config EBTR1 = OFF      // Table Read Protection bit (Block 1 (002000-003FFFh) is not protected from table reads executed in other blocks)
70. #pragma config EBTR2 = OFF      // Table Read Protection bit (Block 2 (004000-005FFFh) is not protected from table reads executed in other blocks)
71. #pragma config EBTR3 = OFF      // Table Read Protection bit (Block 3 (006000-007FFFh) is not protected from table reads executed in other blocks)
72.  
73. // CONFIG7H
74. #pragma config EBTRB = OFF      // Boot Block Table Read Protection bit (Boot block (000000-0007FFh) is not protected from table reads executed in other blocks)
75.  
76.  
77.  
78. //Retardos requeridos por la libreria XLCD
79. void DelayFor18TCY(void);
80. void DelayPORXLCD(void);
81. void DelayXLCD(void);
82.  
83. void main(void)
84. {
85. /* Set RB<4:0> as digital I/O pins (required if config bit PBADEN is set */
86.     ADCON1 = 0x0E;
87.     /* Configure external LCD */
88.     OpenXLCD( FOUR_BIT & LINES_5X7 );
89.     /* Esperamos a que el display este disponible */
90.     while(BusyXLCD());
91.     WriteCmdXLCD( BLINK_ON );
92.     WriteCmdXLCD( SHIFT_DISP_LEFT );
93.      while(1)
94.      {
95.      //Primera línea
96.      SetDDRamAddr(0x00);
97.      putrsXLCD("HOLA");
98.      //Segunda línea
99.      SetDDRamAddr(0x40);
100.      putrsXLCD("MUNDO");
101.      }
102. }
103.  
104. void DelayFor18TCY(void)
105. {
106.     Delay10TCYx(120);
107. }
108. void DelayPORXLCD(void)
109. {
110.     Delay1KTCYx(180);
111.     return;
112. }
113. void DelayXLCD(void)
114. {
115.     Delay1KTCYx(60);
116.     return;
117. }

Gracias por cualquier ayuda aportada.

[Thulsa Doom]

Hola, puede ser problema de la velocidad en el driver del XC8, a mi me pasaba con C18 y después de muchas pruebas era esa la causa

[Miquel_S]

Gracias Thulsa Doom por tu respuesta, he encontrado parte del fallo pero no se el porque, el problema es el LCD que por algún motivo a dejado de funcionar siendo nuevo, de todos modos voy a volver a probarlo con el programa que tengo en ASM para poder descartar que no sea problema del programa mas arriba posteado.

Saludos!

[Miquel_S]

Bueno, después de hacer pruebas tengo lo siguiente:

LCD mod: QC1602A v2.0
Controlador mod: HD44780
Funciona correctamente con programa escrito en ASM.
Funciona de forma errónea con programa escrito en C.  (Código del post anterior)

LCD mod: WM-C1602M
Controlador mod: HD44780
Funciona correctamente con programa escrito en ASM.
Funciona correctamente con programa escrito en C.  (Código del post anterior)

Alguna idea, Gracias.

[KILLERJC]

Tienen el mismo controlador, asi que no deberia haber diferencias.
Pero si podrian ser tiempos, en el que uno sea un poquito mas rapido y no tenga problemas, y el otro no. Los datos que se mandan son iguales asi que tampoco es eso.

Otra explicacion realmente no se me cruza por la cabeza. Aunque si fuera por tiempo podria fallar tambien en la primera pero ocurre a los segundos. Asi que ya con eso va mas a un error del controlador. tal ves se cuelga o algo por el estitlo.

[Thulsa Doom]

También me ha pasado que de entrada funciona bien y cuando llega a una sección del programa empieza a salir caracteres raros, en mi caso era por una estructura que machacó una parte del programa y ocurría eso pero creo que ese no es tu caso. lo digo como curiosidad quien sabe en un futuro lo que pueda pasar 

[marcoj2560456*]

una pregunta estoy tratando de configurar la lcd 2x16 para pic 24fj64gb002 pero he tenido problemas no escribe se ubica en la posicion pero a momento de escribir no lo hace me he ayudado con este tema de xc8 pero estoy utilizando xc16 y he tratado de adaptarlo al compilador las ddiferentes librerias de este curso pero no ha dado resultado por favor si me pudieran ayudar aqui les dejo el programa :

Código: [Seleccionar]

[pre]#include <p24FJ64GB002.h>
#include <stdio.h>
#include <stdlib.h>
#include <libpic30.h>

 //config2
//#pragma config POSCMOD = HS             // Primary Oscillator Select (HS Oscillator mode selected)
#pragma config PLL96MHZ = ON            // 96MHz PLL Startup Select (96 MHz PLL Startup is enabled automatically on start-up)
#pragma config PLLDIV = DIV5            // USB 96 MHz PLL Prescaler Select (Oscillator input divided by 5 (20 MHz input))
//config1
#pragma config FWDTEN = OFF             // Watchdog Timer (Watchdog Timer is disabled)
#pragma config GWRP = OFF               // General Segment Write Protect (Writes to program memory are allowed)
#pragma config GCP = OFF                // General Segment Code Protect (Code protection is disabled)
#pragma config JTAGEN = ON              // JTAG Port Enable (JTAG port is enabled)

#define _XTAL_FREQ 20000000
#define __delay_ms(x) __delay32((unsigned long)((x)*(_XTAL_FREQ/10000.0))) 
#define __delay_us(x) __delay32((unsigned long)((x)*(_XTAL_FREQ/10000000.0)))
#define LED PORTAbits.RA1     
#define ra0 PORTAbits.RA0
#include "xclcd.h"
 
void main(void)
{
    unsigned char alfa[17] = "Peque";
 
    const unsigned char letra[8] = {0b00000000,
                                    0b00001110,
                                    0b00000000,
                                    0b00010110,
                                    0b00011001,
                                    0b00010001,
                                    0b00010001};
     
    unsigned char veces;
       
   
    PORTA = 0;
    TRISA = 0;
  //  PORTB = 0;
  //  TRISB = 0;
 
  lcd_init();
   
        __delay_ms(1500);
    lcd_createchar(1,letra);

        __delay_ms(1500);
    lcd_setdisplay(DISPLAY_OFF);

        __delay_ms(1500);
    lcd_puts("Pequeno");
        __delay_ms(1500);
    lcd_gotoxy(1,2);
        __delay_ms(1500);
    lcd_puts(alfa);
        __delay_ms(1500);
    lcd_putch(1);
        __delay_ms(1500);
    lcd_putch('o');
 
        __delay_ms(1500);

    lcd_setdisplay(CURSOR_ON);

        __delay_ms(1500);

        lcd_puts("hola");

        __delay_ms(1500);
        lcd_gotoxy(1,2);
        __delay_ms(1500);
    lcd_setdisplay(CURSOR_ON);     
__delay_ms(1500);
    lcd_puts("fino");
    while(1)
    {
        LED=1;
        __delay_ms(500);
        LED=0;
        __delay_ms(500);
     
    }
}[/pre]
librerias de angel gris publicado en este post  XCLCD.h

Código: [Seleccionar]

#ifndef XCLCD_H
#define XCLCD_H
 
#ifndef _XC_H_
#include <p24FJ64GB002.h>
#endif
 
/******************************************************************************
 *  Parametros configurables por el usuario                                   *
 ******************************************************************************/
 
/*
 * El valor de _XTAL_FREQ debe coincidir con el valor definido
 * en el programa principal
 */
 
/*
 * LCDEN define el pin EN para el lcd
 * LCDRS define el pin RS para el lcd
 * LCDRW define el pin RW para el lcd
 * LCDDATA define el puerto de datos
 */
 
/*
 * Si se utiliza un pic con resgistros LAT
 * se pueden definir los pines utilizando LAT<x>bits.LAT<x><y>
 * siendo <x> la letra del puerto correspondiente y <y> el bit
 * Tambien se puede definir de la misma manera el puerto de datos
 */
 
/*
 * LCDTRISEN define el bit TRIS para el pin EN
 * LCDTRISRS define el bit TRIS para el pin RS
 * LCDTRISRW define el bit TRIS para el pin RW
 * LCDTRIS define el TRIS correspondiente al puerto de datos
 */
 
/*
 * PROTOCOL4BIT define si se utiliza protocolo de 4 bits
 * PROTOCOL8BIT define si se utiliza protocolo de 8 bits
 */
 
/*
 * En caso de utilizar protocolo de 4 bits
 * UPPER define si se utiliza el nibble alto del puerto
 * LOWER define si se utiliza el nibble bajo del puerto
 */
 
/*
 * En caso de utilizar el pin RW, hay que definir
 * USE_RW
 */
 
#ifndef _XTAL_FREQ
#define _XTAL_FREQ 20000000
#endif
 
#define LCDEN PORTBbits.RB13
#define LCDRS PORTBbits.RB15
#define LCDRW PORTBbits.RB14
#define LCDTRISEN TRISBbits.TRISB13
#define LCDTRISRS TRISBbits.TRISB15
#define LCDTRISRW TRISBbits.TRISB14
#define LCDDATA PORTB
#define LCDTRIS TRISB
#define LCDLAT LATB
#define PROTOCOL4BIT
#define LOWER
#define USE_RW
 
 
/******************************************************************************
 *  Definicion de valores para lcd_setdisplay                                 *
 ******************************************************************************/
/*
 * Los valores se pueden combinar utilizando el operador |
 */
 
#define DISPLAY_OFF 0b00001000
#define DISPLAY_ON  0b00001100
#define CURSOR_OFF  0b00001100
#define CURSOR_ON   0b00001110
#define BLINK_OFF   0b00001100
#define BLINK_ON    0b00001101
 
/******************************************************************************
 *  Definicion de valores para lcd_shift                                      *
 ******************************************************************************/
/*
 * Los valores se pueden combinar utilizando el operador |
 */
 
#define SHIFT_DISPLAY 0b00011000
#define SHIFT_CURSOR  0b00010000
#define SHIFT_LEFT    0b00010000
#define SHIFT_RIGHT   0b00010100
 
/******************************************************************************
 *  Definicion de valores para lcd_entrymode                                  *
 ******************************************************************************/
/*
 * Los valores se pueden combinar utilizando el operador |
 */
 
#define INCREMENT 0b00000110
#define DECREMENT 0b00000100
#define SHIFT_ON  0b00000101
#define SHIFT_OFF 0b00000100
 
 
/******************************************************************************
 *  Definicion de funciones                                                   *
 ******************************************************************************/
 
void lcd_init(void);
void lcd_put(unsigned char, unsigned char);
void lcd_puts(const unsigned char*);
void lcd_gotoxy(unsigned char, unsigned char);
int  lcd_busy(void);
void lcd_putini(unsigned char);
void lcd_createchar(unsigned char, const unsigned char*);
void lcd_setdisplay(unsigned char);
void lcd_shift(unsigned char);
void lcd_entrymode(unsigned char);
 
#define lcd_putch(x) lcd_put(x,1)
#define lcd_clear() lcd_put(0x01,0)
#define lcd_home() lcd_put(0x02,0)
#define lcd_off() lcd_put(0x08,0)
#define lcd_on() lcd_put(0x0C,0)
 
#endif /* XCLCD_H */

y aqui XCLCD.c

Código: [Seleccionar]

#include <p24FJ64GB002.h>
#include "xclcd.h"
#define _XTAL_FREQ 20000000
#define __delay_ms(x) __delay32((unsigned long)((x)*(_XTAL_FREQ/10000.0))) 
#define __delay_us(x) __delay32((unsigned long)((x)*(_XTAL_FREQ/10000000.0)))
#if !defined(LCDEN) || !defined(LCDRS)
#error Faltan definir los pines de control
#elif !defined(LCDTRISEN) || !defined(LCDTRISRS)
#error Falta definir la direccion de los pines de control
#elif !defined(LCDDATA) || !defined(LCDTRIS)
#error Falta definir el puerto y/o el tris de datos
#elif !defined(PROTOCOL4BIT) && !defined(PROTOCOL8BIT)
#error Falta definir el protocolo
#elif defined(PROTOCOL4BIT) && !defined(UPPER) && !defined(LOWER)
#error Falta definir el nibble
#else
 

void lcd_putini(unsigned char data)
{
    unsigned char lasttris;
 
    lasttris = LCDTRIS;
#if defined(PROTOCOL8BIT)
    LCDTRIS = 0;
    LCDDATA = data;
#elif defined(PROTOCOL4BIT)
#if defined(UPPER)
    LCDTRIS &= 0x0F;
    LCDDATA = (LCDDATA & 0x0F) | data;
#elif defined(LOWER)
    LCDTRIS &= 0xF0;
    data = data >> 4;
    LCDDATA = (LCDDATA & 0xF0) | data;
#endif
#endif
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
    LCDTRIS = lasttris;
}
 
void lcd_put(unsigned char data, unsigned char reg)
{
    unsigned char lasttris;
 
    lasttris = LCDTRIS;
#if defined (USE_RW)
    while(lcd_busy() == 1);
#else
    __delay_ms(2);
#endif
    LCDRS = reg;
    LCDRW = 0;
#if defined(PROTOCOL8BIT)
    LCDTRIS = 0;
    LCDDATA = data;
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
#elif defined(PROTOCOL4BIT)
#if defined(UPPER)
    LCDTRIS &= 0x0F;
    LCDDATA = (LCDDATA & 0x0F) | (data & 0xF0);
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
    __delay_us(1);
    LCDDATA = (LCDDATA & 0x0F) | (data << 4);
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
#elif defined(LOWER)
    LCDTRIS &= 0xF0;
    LCDDATA = (LCDDATA & 0xF0) | (data >> 4);
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
    __delay_us(1);
    LCDDATA = (LCDDATA & 0xF0) | (data & 0x0F);
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
#endif
 
#endif
    LCDTRIS = lasttris;
}
 
void lcd_init(void)
{
    unsigned char veces;
 
    LCDEN = 0;
    LCDRS = 0;
    LCDRW = 0;
    LCDTRISRS = 0;
    LCDTRISRW = 0;
    LCDTRISEN = 0;
   
    __delay_ms(15);
   
    for (veces = 3; veces > 0; veces--)
    {
    lcd_putini(0x30);
    __delay_ms(5);
    }
#if defined(PROTOCOL8BIT)
    lcd_put(0x38,0);                          // Dos lineas, caracter 5x8
#elif defined(PROTOCOL4BIT)
    lcd_putini(0x20);                         // Protocolo de 4 bits
    lcd_put(0x28,0);                          // Dos lineas, caracter 5x8
#endif
    lcd_put(0x08,0);                          // Apagar display, cursor, blink
    lcd_put(0x01,0);                          // Borrar display
    lcd_put(0x06,0);                          // Incrementa posicion, sin shift
}
 

int lcd_busy(void)
{
    unsigned char lasttris;
    unsigned char busy;
 
    lasttris = LCDTRIS;
    LCDRS = 0;
    LCDRW = 1;
#if defined(PROTOCOL8BIT)
    LCDTRIS = 0xFF;
    LCDEN = 1;
    __delay_us(1);
    busy = LCDDATA;
    LCDEN = 0;
#elif defined(PROTOCOL4BIT)
#if defined(UPPER)
    LCDTRIS = (LCDTRIS & 0x0F) | 0xF0;
    LCDEN = 1;
    __delay_us(1);
    busy = LCDDATA;
    LCDEN = 0;
    __delay_us(1);
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
#elif defined(LOWER)
    LCDTRIS = (LCDTRIS & 0xF0) | 0x0F;
    LCDEN = 1;
    __delay_us(1);
    busy = LCDDATA << 4;
    LCDEN = 0;
    __delay_us(1);
    LCDEN = 1;
    __delay_us(1);
    LCDEN = 0;
#endif
#endif
    LCDTRIS = lasttris;
    if ((busy & 0x80) == 0x80) return 1;
    else
        return 0;
}
 
void lcd_gotoxy(unsigned char x, unsigned char y)
{
    x--;
    y--;
    if (y == 0) lcd_put((0x80 + x),0);
    else
        lcd_put((0xC0 + x),0);
}
 
void lcd_puts(const unsigned char *st)
{
    while (*st != 0)
    {
        lcd_put(*st,1);
        st++;
    }
}
 
void lcd_createchar(unsigned char asciicode, const unsigned char* ascii)
{
    unsigned char line;
    unsigned char caracter;
 
    for (line = 0; line < 7; line++)
    {
        caracter = (((asciicode & 0x07) << 3) | (0x40 + line));
        lcd_put(caracter,0);
        lcd_put(*ascii,1);
        ascii++;
    }
    caracter = ((asciicode & 0x07) << 3) | 0x47;
    lcd_put(caracter,0);
    lcd_put(0,1);
    lcd_clear();
}
 
void lcd_setdisplay(unsigned char state)
{
    lcd_put(state,0);
}
 
void lcd_shift(unsigned char state)
{
    lcd_put(state,0);
}
 
void lcd_entrymode(unsigned char state)
{
    lcd_put(state,0);
}
#endif

agradeceria muchisimo la ayuda

[KILLERJC]

Primero que nada la libreria esta realizado para un dispositivo con registros de 8 bits. Entonces cuando modifica los TRIS son con valores de 0x0F o 0xF0 que si lo transportas a 16bits quedarian 0x000F y 0x00F0, pero como ese ultimo valor esta mal ya que deberia haber sido 0xFFF0. Vas a tener que adaptar la libreria al pic24, para eso vas a tener inevitablemente que aprender como es que se comunica con el LCD. Rara ves una libreria sacada de internet te va a funcionar.


En mi opinion personal: Usar un pic24 ya no estas para hacer eso de copiar y pegar, ya debes aprender a hacerte tus propias librerias, entender como funciona, leerte los datasheet, podes apoyarte sobre una libreria hecha lo que hace que sea mas facil hacerla por vos mismo, pero ahi vas a aprender como hacer las cosas y vas a encontrar los problemas. Esto no es un problema de sintaxis, esta todo bien, sino un problema de programacion o portabilidad. Si alguno te quiere dar una mano y te pasa un codigo, excelente. Pero lo que respecta a mi, y mi consejo hacia vos, es que aprendas a hacerte tus propias librerias.