LCD y pic 16f en CSS

[cucu]

Hola, estoy intentando escribir datos por el LCD con mi pic 16F, progrmamando en CSS. Utilizando la librería del LCD todo funciona correctametne.

El problema está en que quiero cambiar el puerto B por el C puesto que necesito la interrupción de RB4.

Sólo cambio eso, para ello, en la librería cambio:

Código: [Seleccionar]

#byte lcd_b = 6 ----------------------------> #byte lcd_c = 7

set_tris_b(0xxx);---------------------------> set_tris_c =(0xxx)




No veo nada más que debiera cambiar, sin embargo deja de funcionar.


¿Qué puede estar pasando?

Gracias. Saludos

[migsantiago]

Hola

Dinos qué versión de CCS usas. En versiones anteriores la librería solo funciona con puerto B o D. Pero hace unos días estaba viendo que la lcd.c de la versión 4.084 ya funciona de forma universal. Se pueden distribuir los 7 pines de control de la lcd en cualquier arreglo de 7 pines del pic (parecida a la flexlcd).

[Suky]

Sino más sencillo reemplazala directamente por lcd_flex(), te la adjunto...

[MLO__]

Hola.

Solo son dos cambios:

Código: [Seleccionar]

#define use_portc_lcd TRUE

Defino esta nueva directiva -para elegir, entre B,C o D-

Código: C#

1. #elif defined use_portc_lcd
2.    #locate lcd = getenv("sfr:PORTC")
3.    #define set_tris_lcd(x) set_tris_c(x)

defino la direccion del puerto.

Y listo.

Saludos

[chuletiya]

Hola. Estoy intentando escribir datos por el LCD con mi pic 16F876A, programando en CSS.Estoy utilizando la libreria lcd2.c que es de 8 bits,pero necesito modificarla para utilizarla con elpuerto C puesto que el puerto B lo necesito para la interrupcion RB4.¿Cuales serian esas modificaciones que he de realizar para que el lcd funcione correctamente?

He probado ya varias opciones pero no doy con la solucion,espero que podais ayudarme.Utilizo la version 4.023 de CCS

Aqui dejo el codigo de la libreria lcd2.c:

#bit  lcd_enable = 5.3      //RA3 --> Enable
#bit  lcd_rw     = 5.2      //RA2 --> R/W
#bit  lcd_rs     = 5.1      //RA1 --> RS
#byte lcd_a = 5            //Puerta A
#byte lcd_b = 6            //Puerta B

#define LCD_LINEA2 0x40    // Dirección de memoria para la segunda línea
#define LCD_DATO    1      // Modo dato
#define LCD_COMANDO 0      // Modo comando

//Definición de los códigos de los comandos mas frecuentes

#define LCD_CLEAR       0x01
#define LCD_HOME       0x02

#define LCD_DISPLAY_OFF  0x08
#define LCD_DISPLAY_ON   0x0C
#define LCD_CURSOR_ON    0x0E
#define LCD_CURSOR_BLINK 0x0F

#define LCD_CURSOR_SHIFT_RIGHT  0x10
#define LCD_CURSOR_SHIFT_LEFT   0x14
#define LCD_DISPLAY_SHIFT_RIGHT 0x18
#define LCD_DISPLAY_SHIFT_LEFT  0x1C

//Realiza un ciclo de lectura de la pantalla LCD

int lcd_leer()   
{
  int valor;

  set_tris_a(0x11);   //RA1-RA3 se configuran como salidas
  set_tris_b(0xFF);   //RB0-RB7 se configuran como entradas

  lcd_rw = 1;      //Modo lectura
  delay_cycles(1);
  lcd_enable = 1;   //Activación del LCD
  delay_cycles(1);
  valor = lcd_b;   //Lectura de datos procedentes de LCD
  lcd_enable = 0;   //Desactivación del LCD
  delay_cycles(1);

  set_tris_b(0x00);   //RB0-RB7 se configuran como salidas
  return valor;
}

//Envia a la pantalla un comando (dir=1) o un dato (dir=0)

void lcd_enviar(int dir, int valor)
{
  set_tris_a(0x00);
  set_tris_b(0x00);   //Puerta A y B salidas

  lcd_rs = 0;      //Modo comando
  while( bit_test(lcd_leer(),7) );   // Lectura del biy bussy del LCD para saber si está libre
  lcd_rs = dir;      //Establece el modo (comando/dato)
  delay_cycles(1);

  lcd_rw = 0;      //Modo escritura
  delay_cycles(1);
  lcd_enable = 0;
  lcd_b = valor;   //Envia el valor del comando o del dato
  delay_cycles(1);
  lcd_enable = 1;   //Habilita el LCD
  delay_us(2);
  lcd_enable = 0;   //Desactiva el LCD
}


//Función para inicio de la pantalla LCD según especificaciones del fabricante

void lcd_init()
{
  int i;

  set_tris_a(0x11);   //RA1-RA3 salidas
  set_tris_b(0x00);   //RB0-RB7 salidas

  lcd_enable = 0;   //Desactiva LCD
  lcd_rw = 0;      //Modo escritura
  lcd_rs = 0;      //Modo comando
  delay_ms(15);      //Temporiza 15mS

  for(i=0; i<3; i++)   //Envía 3 veces el comando 0x38 a intervalos de 5 mS
  {
    lcd_enviar(LCD_COMANDO,0x38);
    delay_ms(5);
  }
  lcd_enviar(LCD_COMANDO,LCD_DISPLAY_ON);   //Secuencia de comandos a enviar a la pantalla LCD
  lcd_enviar(LCD_COMANDO,0x06);
  lcd_enviar(LCD_COMANDO,LCD_CLEAR);
  lcd_enviar(LCD_COMANDO,LCD_HOME);
}

//Función para situar el cursor

void lcd_gotoxy( byte x, byte y) {
   byte dir;

   if(y!=1)
     dir=LCD_LINEA2;
   else
     dir=0;
   dir+=x-1;
   lcd_enviar(LCD_COMANDO,0x80|dir);
}

//Visualiza un caracter

void lcd_putc( char c) {
   switch (c) {
     case '\f'   : lcd_enviar(LCD_COMANDO,0x01);
                   delay_ms(2);
                   break;
     case '\n'   : lcd_gotoxy(1,2);               break;
     case '\b'   : lcd_enviar(LCD_COMANDO,0x10);  break;
     default     : lcd_enviar(LCD_DATO,c);        break;
   }
}

//Devuelve el caracter

char lcd_getc( int x, int y) {
   char valor;

    lcd_gotoxy(x,y);

    lcd_rs = 1;
    valor = lcd_leer();
    lcd_rs = 0;

    return valor;
}


Gracias.Saludos.

[Suky]

Así debería funcionar:

Código: C

1. #bit  lcd_enable = 5.3      //RA3 --> Enable
2. #bit  lcd_rw     = 5.2      //RA2 --> R/W
3. #bit  lcd_rs     = 5.1      //RA1 --> RS
4. #byte lcd_a = 5            //Puerta A
5. #byte lcd_c = 7            //Puerta C
6.  
7. #define LCD_LINEA2 0x40    // Dirección de memoria para la segunda línea
8. #define LCD_DATO    1      // Modo dato
9. #define LCD_COMANDO 0      // Modo comando
10.  
11. //Definición de los códigos de los comandos mas frecuentes
12.  
13. #define LCD_CLEAR       0x01
14. #define LCD_HOME       0x02
15.  
16. #define LCD_DISPLAY_OFF  0x08
17. #define LCD_DISPLAY_ON   0x0C
18. #define LCD_CURSOR_ON    0x0E
19. #define LCD_CURSOR_BLINK 0x0F
20.  
21. #define LCD_CURSOR_SHIFT_RIGHT  0x10
22. #define LCD_CURSOR_SHIFT_LEFT   0x14
23. #define LCD_DISPLAY_SHIFT_RIGHT 0x18
24. #define LCD_DISPLAY_SHIFT_LEFT  0x1C
25.  
26. //Realiza un ciclo de lectura de la pantalla LCD
27.  
28. int lcd_leer()  
29. {
30.   int valor;
31.  
32.   set_tris_a(0x11);   //RA1-RA3 se configuran como salidas
33.   set_tris_c(0xFF);   //RC0-RC7 se configuran como entradas
34.  
35.   lcd_rw = 1;      //Modo lectura
36.   delay_cycles(1);
37.   lcd_enable = 1;   //Activación del LCD
38.   delay_cycles(1);
39.   valor = lcd_c;   //Lectura de datos procedentes de LCD
40.   lcd_enable = 0;   //Desactivación del LCD
41.   delay_cycles(1);
42.  
43.   set_tris_c(0x00);   //RC0-RC7 se configuran como salidas
44.   return valor;
45. }
46.  
47. //Envia a la pantalla un comando (dir=1) o un dato (dir=0)
48.  
49. void lcd_enviar(int dir, int valor)
50. {
51.   set_tris_a(0x00);
52.   set_tris_c(0x00);   //Puerta A y C salidas
53.  
54.   lcd_rs = 0;      //Modo comando
55.   while( bit_test(lcd_leer(),7) );   // Lectura del biy bussy del LCD para saber si está libre
56.   lcd_rs = dir;      //Establece el modo (comando/dato)
57.   delay_cycles(1);
58.  
59.   lcd_rw = 0;      //Modo escritura
60.   delay_cycles(1);
61.   lcd_enable = 0;
62.   lcd_c = valor;   //Envia el valor del comando o del dato
63.   delay_cycles(1);
64.   lcd_enable = 1;   //Habilita el LCD
65.   delay_us(2);
66.   lcd_enable = 0;   //Desactiva el LCD
67. }
68.  
69.  
70. //Función para inicio de la pantalla LCD según especificaciones del fabricante
71.  
72. void lcd_init()
73. {
74.   int i;
75.  
76.   set_tris_a(0x11);   //RA1-RA3 salidas
77.   set_tris_c(0x00);   //RC0-RC7 salidas
78.  
79.   lcd_enable = 0;   //Desactiva LCD
80.   lcd_rw = 0;      //Modo escritura
81.   lcd_rs = 0;      //Modo comando
82.   delay_ms(15);      //Temporiza 15mS
83.  
84.   for(i=0; i<3; i++)   //Envía 3 veces el comando 0x38 a intervalos de 5 mS
85.   {
86.     lcd_enviar(LCD_COMANDO,0x38);
87.     delay_ms(5);
88.   }
89.   lcd_enviar(LCD_COMANDO,LCD_DISPLAY_ON);   //Secuencia de comandos a enviar a la pantalla LCD
90.   lcd_enviar(LCD_COMANDO,0x06);
91.   lcd_enviar(LCD_COMANDO,LCD_CLEAR);
92.   lcd_enviar(LCD_COMANDO,LCD_HOME);
93. }
94.  
95. //Función para situar el cursor
96.  
97. void lcd_gotoxy( byte x, byte y) {
98.    byte dir;
99.  
100.    if(y!=1)
101.      dir=LCD_LINEA2;
102.    else
103.      dir=0;
104.    dir+=x-1;
105.    lcd_enviar(LCD_COMANDO,0x80|dir);
106. }
107.  
108. //Visualiza un caracter
109.  
110. void lcd_putc( char c) {
111.    switch (c) {
112.      case '\f'   : lcd_enviar(LCD_COMANDO,0x01);
113.                    delay_ms(2);
114.                    break;
115.      case '\n'   : lcd_gotoxy(1,2);               break;
116.      case '\b'   : lcd_enviar(LCD_COMANDO,0x10);  break;
117.      default     : lcd_enviar(LCD_DATO,c);        break;
118.    }
119. }
120.  
121. //Devuelve el caracter
122.  
123. char lcd_getc( int x, int y) {
124.    char valor;
125.  
126.     lcd_gotoxy(x,y);
127.  
128.     lcd_rs = 1;
129.     valor = lcd_leer();
130.     lcd_rs = 0;
131.  
132.     return valor;
133. }

[chuletiya]

He probado esas modificaciones y el LCD no se enciende,no se que puede estar pasando.

¿El empleo de una version u otra del compilador CCS influye en el buen funcionamiento de la libreria LCD.C y LCD2.C?


Gracias.Saludos

[MLO__]

Hola.

Esta a mi me ha funcionado bien en el puerto C:

Código: C#

1. // As defined in the following structure the pin connection is as follows:
2. //     RC0  rs      [4]
3. //     RC1  rw      [5]
4. //     RC2  en      [6]
5. //     RC4  D4      [11]
6. //     RC5  D5      [12]
7. //     RC6  D6      [13]
8. //     RC7  D7      [14]
9. //
10. //   LCD pins D0-D3 are not used and PIC D3 is not used.
11.  
12. // Un-comment the following define to use port C
13.  #define use_portc_lcd TRUE //Cambio la directiva segun el puerto que quiera usar
14.  
15. #define LCD_OFF                 0x08
16. #define CURSOR_ON               0x0E
17. #define CURSOR_OFF              0x0C
18. #define BLINK_ON                0x0D
19. #define BLINK_OFF               0x0C
20. #define SHIFT_LEFT              0x1C
21. #define SHIFT_RIGHT             0x18
22. #define CURSOR_RIGHT    0x14
23. #define CURSOR_LEFT             0x10
24. #define CGRAM                   0x40
25. #define DDRAM                   0x80
26.  
27.  
28. struct lcd_pin_map {            
29.            BOOLEAN rs;
30.            BOOLEAN rw;
31.            BOOLEAN enable;
32.            BOOLEAN unused;  
33.            int     data : 4;        
34.         } lcd;
35.  
36.  
37. #if defined use_portb_lcd
38.    #locate lcd = getenv("sfr:PORTB")    // This puts the entire structure over the port
39.    #define set_tris_lcd(x) set_tris_b(x)
40. #elif defined use_portc_lcd // Habilito la directiva de compilacion para trabajar el puerto C
41.    #locate lcd = getenv("sfr:PORTC")
42.    #define set_tris_lcd(x) set_tris_c(x)
43. #else
44.    #locate lcd = getenv("sfr:PORTD")    // This puts the entire structure over the port
45.    #define set_tris_lcd(x) set_tris_d(x)
46. #endif
47.  
48.  
49. #define lcd_type 2           // 0=5x7, 1=5x10, 2=2 lines
50. #define lcd_line_two 0x40    // LCD RAM address for the second line
51.  
52.  
53. BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
54.                              // These bytes need to be sent to the LCD
55.                              // to start it up.
56.  
57.  
58.                              // The following are used for setting
59.                              // the I/O port direction register.
60.  
61. struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out
62. struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in
63.  
64.  
65.  
66. BYTE lcd_read_byte() {
67.       BYTE low,high;
68.       set_tris_lcd(LCD_READ);
69.       lcd.rw = 1;
70.       delay_cycles(1);
71.       lcd.enable = 1;
72.       delay_cycles(1);
73.       high = lcd.data;
74.       lcd.enable = 0;
75.       delay_cycles(1);
76.       lcd.enable = 1;
77.       delay_us(1);
78.       low = lcd.data;
79.       lcd.enable = 0;
80.       set_tris_lcd(LCD_WRITE);
81.       return( (high<<4) | low);
82. }
83.  
84.  
85. void lcd_send_nibble( BYTE n ) {
86.       lcd.data = n;
87.       delay_cycles(1);
88.       lcd.enable = 1;
89.       delay_us(2);
90.       lcd.enable = 0;
91. }
92.  
93.  
94. void lcd_send_byte( BYTE address, BYTE n ) {
95.  
96.       lcd.rs = 0;
97.       while ( bit_test(lcd_read_byte(),7) ) ;
98.       lcd.rs = address;
99.       delay_cycles(1);
100.       lcd.rw = 0;
101.       delay_cycles(1);
102.       lcd.enable = 0;
103.       lcd_send_nibble(n >> 4);
104.       lcd_send_nibble(n & 0xf);
105. }
106.  
107.  
108. void lcd_init() {
109.     BYTE i;
110.     set_tris_lcd(LCD_WRITE);
111.     lcd.rs = 0;
112.     lcd.rw = 0;
113.     lcd.enable = 0;
114.     delay_ms(15);
115.     for(i=1;i<=3;++i) {
116.        lcd_send_nibble(3);
117.        delay_ms(5);
118.     }
119.     lcd_send_nibble(2);
120.     for(i=0;i<=3;++i)
121.        lcd_send_byte(0,LCD_INIT_STRING[i]);
122. }
123.  
124.  
125. void lcd_gotoxy( BYTE x, BYTE y) {
126.    BYTE address;
127.  
128.    if(y!=1)
129.      address=lcd_line_two;
130.    else
131.      address=0;
132.    address+=x-1;
133.    lcd_send_byte(0,0x80|address);
134. }
135.  
136. void lcd_putc( char c) {
137.    switch (c) {
138.      case '\f'   : lcd_send_byte(0,1);
139.                    delay_ms(2);
140.                                            break;
141.      case '\n'   : lcd_gotoxy(1,2);        break;
142.      case '\b'   : lcd_send_byte(0,0x10);  break;
143.      default     : lcd_send_byte(1,c);     break;
144.    }
145. }
146.  
147. char lcd_getc( BYTE x, BYTE y) {
148.    char value;
149.  
150.     lcd_gotoxy(x,y);
151.     while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
152.     lcd.rs=1;
153.     value = lcd_read_byte();
154.     lcd.rs=0;
155.     return(value);
156. }
157.  
158. void lcd_command(byte cmd)
159. {
160.         lcd_send_byte(0, cmd);
161. }

La probe sobre un 16F873A:



Saludos

[chuletiya]

MLO__ ya he conseguido que se encienda el LCD.

Gracias.Saludos