¿Generar nuevos caracteres en LCD?

[Cryn]

Disculpen por entrometerme, digamos que estos son los datos:

int const caracter0_direccion[8]={0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47};
int const caracter0_datos[8]={0b00100,0b01110,0b10101,0b00100,0b10101,0b01110,0b00100,0b0};

entonces al hacer:
for(contador=0;contador<8;contador++){
     lcd_send_byte(0,caracter0_direccion[contador]);   //modo comando
     lcd_send_byte(1,caracter0_datos[contador]);        // modo dato
}

Los datos que están en el segundo arreglo serán los de la posición 0 en la tabla ASCII del LCD, que corresponde a nuestro caracter diseñado, que en realidad se encuentran a partir de la posición 0x40 a 0x47 en la memoria del LCD

entonces para llamar a ese nuevo carácter generado simplemente haces:
lcd_putc(0);

ó
print(lcd_putc,"%c",0);

o con un define como hizo MLO__:
#define new_caracter 0
print(lcd_putc,"%c",new_caracter);

El siguiente caracter creado estará a partir de la posición 0x48 a 0x4f, pero para llamarlo se usa el valor 1:
lcd_putc(1);

y así sucesivamente hasta llegar al tope en memoria dispoble y en la tabla ASCII correspondiente, solo se pueden crear 8 caracteres, si es que no me equivoco.

Ya después puedes también utilizar todo el poder del printf, por ejemplo: supongamos que no existe una ñ, entonces haces, previamente guardado un caracter en las primeras posiciones de la CG-RAM (0x40-0x47):
printf(lcd_putc,"A%co",new_caracter);

espero te sirva de ayuda, un saludo.

[micro_pepe]

Disculpen por entrometerme, digamos que estos son los datos:

De ninguna manera te entrometes, has dado en el clavo 

A continuación os dejo un programa de ejemplo con las pautas de Cryn. Lo que hace es mostrar una barra que va creciendo de izquierda a derecha.

Solo una pregunta, he incluido la rutina de mostrar la barra en el programa final en el que se va a emplear, y en el programa principal tengo la lectura de un mando a distancia que no puede ser interrumpido; pues bien al incluir la rutina de la barra, la lectura del mando no funciona. Lo he solucionado poniendo esa parte del programa principal en una interrupción, pero me gustaria saber si el echo de meter datos en la memoria del LCD produce interrupciones o algo asi que pueda afectar al programa principal.

Código: [Seleccionar]

#include <16F876A.h>
#fuses XT,NOWDT,PUT
#use delay(clock=4000000)

#byte porta =5
#byte portb =6
//#define use_portb_lcd TRUE
//#include <LCD.c>
/******************************************************************************/
/* Definiciones para la interfaz PIC-LCD                                      */
/******************************************************************************/
# define PORTA 0x05// Puerto A
# define PORTB 0x06// Puerto B
# define PORTC 0x07// Puerto C
# define TRISA 0x85// Registro de direccionamiento Puerto A
# define TRISB 0x86// Registro de direccionamiento Puerto B
# define TRISC 0x87// Registro de direccionamiento Puerto C
//Se definen los terminales de conexion del display
#bit lcd_db4 = PORTA.2
#bit tris_lcd_db4 = TRISA.2
#bit lcd_db5 = PORTA.3
#bit tris_lcd_db5 = TRISA.3
#bit lcd_db6 = PORTA.4
#bit tris_lcd_db6 = TRISA.4
#bit lcd_db7 = PORTA.5
#bit tris_lcd_db7 = TRISA.5

#bit lcd_en = PORTC.0
#bit tris_lcd_en = TRISC.0
#bit lcd_rs = PORTC.1
#bit tris_lcd_rs = TRISC.1
# include <lcd_flex.c>

//*****************************************************************************
int const caracter0_direccion[8]={0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47};
int const caracter0_datos[8]={0b10000,0b10000,0b10000,0b10000,0b10000,0b10000,0b10000,0b0};

int const caracter1_direccion[8]={0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f};
int const caracter1_datos[8]={0b11000,0b11000,0b11000,0b11000,0b11000,0b11000,0b11000,0b0};

int const caracter2_direccion[8]={0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57};
int const caracter2_datos[8]={0b11100,0b11100,0b11100,0b11100,0b11100,0b11100,0b11100,0b0};

int const caracter3_direccion[8]={0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f};
int const caracter3_datos[8]={0b11110,0b11110,0b11110,0b11110,0b11110,0b11110,0b11110,0b0};

int const caracter4_direccion[8]={0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67};
int const caracter4_datos[8]={0b11111,0b11111,0b11111,0b11111,0b11111,0b11111,0b11111,0b0};

int8 vol;

//****************************************************************************//
//Muestra una barra en el LCD.                                                //
//****************************************************************************//
void MostrarBarraLCD(int8 Volumen){
int contador, aux, Columna;

for(contador=0;contador<8;contador++){
lcd_send_byte(0,caracter0_direccion[contador]);   //modo comando
lcd_send_byte(1,caracter0_datos[contador]);        // modo dato
lcd_send_byte(0,caracter1_direccion[contador]);   //modo comando
lcd_send_byte(1,caracter1_datos[contador]);        // modo dato
lcd_send_byte(0,caracter2_direccion[contador]);   //modo comando
lcd_send_byte(1,caracter2_datos[contador]);        // modo dato
lcd_send_byte(0,caracter3_direccion[contador]);   //modo comando
lcd_send_byte(1,caracter3_datos[contador]);        // modo dato
lcd_send_byte(0,caracter4_direccion[contador]);   //modo comando
lcd_send_byte(1,caracter4_datos[contador]);        // modo dato
}
lcd_send_byte(0,0x80);

lcd_gotoxy(1,2);
printf(lcd_putc,"                ");

aux=Volumen;
Columna=1;
while(aux>=5){//Por cada pasada muestra un cuadro.
   aux=aux-5;
   lcd_gotoxy(Columna,2);
   printf(lcd_putc,"%c",4);
   Columna++;
}
lcd_gotoxy(Columna,2);
switch (aux) {
   case    0x01: printf(lcd_putc,"%c",0);
      Break;
   case    0x02: printf(lcd_putc,"%c",1);
      Break;
   case    0x03: printf(lcd_putc,"%c",2);
      Break;
   case    0x04: printf(lcd_putc,"%c",3);
      Break;
}
}
//****************************************************************************//

void main() {
set_tris_a(0x0);
set_tris_b(0x0);
lcd_init();
   vol=0;
   while(1){
   MostrarBarraLCD(vol);
   vol++;
   if(vol>80)
        vol=0;
   delay_ms(100);
   }
}



[Cryn]

Que bueno que te haya servido

Creo que una vez almacenado el dato en la memo del LCD ahí esta disponible para que lo uses siempre que tenga energía y será como cualquier otra letra, si quieres mostrar una especie de animación y que necesite que constantemente se utilice el LCD tendrás que ver la manera para atender varias cosas, como las interrupciones como mencionaste, mostrar tu caracter especial es como mostrar una 'a' por ejemplo no genera ninguna interrupción ni mucho menos al momento de la grabación en la cg-ram.

Si tienes todos los movimientos fríamente calculados, no pasa nada

[micro_pepe]

Habro este viejo hilo de nuevo, resulta que tengo una librería para manejar un LCD con un modulito i2c, con caracteres de los que trae la pantalla funciona perfectamente, pero ahora quiero agregar caracteres definidos por mi; la librería es esta:

Código: C

1. extern void DelayMsec(unsigned int n_ms);
2. #define LCD_ADDR       0x7E //I2C slave address for LCD module El PCF8574AT y
3. //el PCF8574T tienen direcciones distintas.
4.  
5. #define ON             1
6. #define OFF            0
7. #define LCD_MODO_DATO      1
8. #define LCD_MODO_COMANDO   0
9. #define RS             0b00000001  //P0 - PCF8574T Pin connected to RS
10. #define RW             0b00000010  //P1 - PCF8574T Pin connected to RW
11. #define EN             0b00000100  //P2 - PCF8574T Pin connected to EN
12. #define BACKLIGHT_LED  0b00001000  //P3 - PCF8574T Pin connected to BACKLIGHT LED
13.  
14. #define lcd_line_one   0x80   // LCD RAM address for line 1
15. #define lcd_line_two   0xC0   // LCD RAM address for line 2
16. #define lcd_line_three 0x94   // LCD RAM address for line 3
17. #define lcd_line_four  0xD4   // LCD RAM address for line 4
18.  
19. unsigned int address;
20. bit lcd_backlight;
21.  
22. void i2c_send_nibble(unsigned char data) {
23.     StartI2C(); // begin I2C communications
24.     __delay_us(20);
25.     IdleI2C();
26.     WriteI2C(LCD_ADDR); // addresses the chip
27.     __delay_us(20);
28.     IdleI2C();
29.     WriteI2C(data);
30.     __delay_us(20);
31.     IdleI2C();
32.     StopI2C();
33.     __delay_us(20);
34. }
35.  
36. void lcd_send_byte(unsigned char data) {
37.     if (lcd_backlight) data = data | EN | BACKLIGHT_LED;
38.     else data = data | EN; //set pin EN
39.     i2c_send_nibble(data);
40.     data = data & 0B11111011; //toggle EN back to 0
41.     i2c_send_nibble(data);
42. }
43.  
44. void lcd_clear() {
45.     lcd_send_byte(0x00);
46.     lcd_send_byte(0x10);
47.     DelayMsec(12);
48. }
49.  
50. void lcd_init() {
51.     DelayMsec(200); //LCD power up delay
52.  
53.     //Request works on the command by set the RS = 0 R/W = 0 write
54.     lcd_send_byte(0x00);
55.     lcd_send_byte(0x10);
56.     lcd_send_byte(0x00);
57.     lcd_send_byte(0x00);
58.     lcd_send_byte(0x10);
59.     //First state in 8 bit mode
60.     lcd_send_byte(0x30);
61.     lcd_send_byte(0x30);
62.     //Then set to 4-bit mode
63.     lcd_send_byte(0x30);
64.     lcd_send_byte(0x20);
65.     //mode 4 bits, 2 lines, characters 5 x 7 (28 h)
66.     lcd_send_byte(0x20);
67.     lcd_send_byte(0x80);
68.     //no need cursor on (0Ch)
69.     lcd_send_byte(0x00);
70.     lcd_send_byte(0xC0);
71.     //the cursor moves to the left (06 h)
72.     lcd_send_byte(0x00);
73.     lcd_send_byte(0x60);
74.     //clears the display
75.     lcd_clear();
76. }
77.  
78. void lcd_gotoxy(unsigned char x, unsigned char y) {
79.     static char data;
80.  
81.     switch (y) {
82.         case 1: address = lcd_line_one;
83.             break;
84.         case 2: address = lcd_line_two;
85.             break;
86.         case 3: address = lcd_line_three;
87.             break;
88.         case 4: address = lcd_line_four;
89.             break;
90.         default: address = lcd_line_one;
91.             break;
92.     }
93.  
94.     address += x - 1;
95.     data = address & 0xF0;
96.     lcd_send_byte(data);
97.     data = address & 0x0F;
98.     data = data << 4;
99.     lcd_send_byte(data);
100. }
101.  
102. void i2c_lcd_backlight_On() {
103.     lcd_backlight = ON;
104. }
105.  
106. void i2c_lcd_backlight_Off() {
107.     lcd_backlight = OFF;
108. }
109.  
110. //Display the character on LCD screen.
111.  
112. void LCD_PUTC(char in_data) {
113.     char data;
114.     switch (in_data) {
115.         case '\f': lcd_clear();
116.             break;
117.         case '\1': lcd_gotoxy(1, 1);
118.             break;
119.         case '\2': lcd_gotoxy(1, 2);
120.             break;
121.         case '\3': lcd_gotoxy(1, 3);
122.             break;
123.         case '\4': lcd_gotoxy(1, 4);
124.             break;
125.  
126.         default:
127.             data = in_data & 0xF0;
128.             data = data | RS; //set RS pin to 1
129.             lcd_send_byte(data);
130.             data = in_data & 0x0F;
131.             data = data << 4;
132.             data = data | RS; //set RS pin to 1
133.             lcd_send_byte(data);
134.             break;
135.     }
136. }
137.  
138. void LCDprint(char * buff, unsigned char len) {
139.     unsigned char i;
140.     for (i = 0; i < len; i++) {
141.         LCD_PUTC(*(buff++));
142.     }
143. }

He intentado hacer cosas parecidas a las del hilo, pero no funcionan, en mi librería no tengo la opción de mandar bytes en modo comando o dato, pero creo que LCD_PUTC lo hace en modo dato (pues pone el pin RS a uno) y lcd_send_byte en modo comando, ¿alguna idea?

Gracias, un saludo!!!

[KILLERJC]

Y por que no crear tu propia funcion de enviar comandos ?
Utilizando el gotoxy, que para seleccionar la direccion de la RAM es un comando, podria hacer:
RS debe estar en 0 para un comando.

Código: C

1. void lcd_SendCommand(unsigned char command) {
2.  
3.     unsigned char data;
4.  
5.     data = command & 0xF0;
6.     lcd_send_byte(data);
7.     data = command & 0x0F;
8.     data = data << 4;
9.     lcd_send_byte(data);
10. }

De ahi deberias setear la direccion con el comando 01AA AAAA, que por ser la CGRAM comienza en 0. es decir enviar 0100 0000 o 0x40. Y de ahi proceder a escribir las 7 lineas para tu caracter con alguna otra funcion extrayendo lo importante de LCD_PUTC, ya que si cae en alguno de los valores del switch es un problema.

Código: C

1. void lcd_SendData(unsigned char in_data) {
2.  
3.         unsigned char data;
4.  
5.     data = in_data & 0xF0;
6.     data = data | RS; //set RS pin to 1
7.     lcd_send_byte(data);
8.     data = in_data & 0x0F;
9.     data = data << 4;
10.     data = data | RS; //set RS pin to 1
11.     lcd_send_byte(data);
12. }

Observa que creado esta funcion, LCD_PUTC se podria reemplazar el default, con esa funcion sin problemas.

[micro_pepe]

OK, gracias!!! así funciona 

La librería queda así:

Código: C

1. //-----------------------------------------------------------------------------
2. // Title:         i2c_Flex_LCD
3. // Description:   Driver for common LCD with 1/2/3 or 4 row modules using PCF8574T interface board with I2C protocol.
4. // Date:          Nov-2013
5. // Ver.Rev.:      1.0
6. // Author:        Hugo Silva (sergio-hugo@bol.com.br) #Based on the routines of 20X4_LCD_I2C_DRIVER.h from Pumrin S.
7. //-----------------------------------------------------------------------------
8. //
9. // lcd_init() Must be called before any other function.
10. //
11. // lcd_putc(c) Will display c on the next position of the LCD.
12. //
13. //     \f Clear LCD dispay
14. //     \1 Set write position on LCD Line 1
15. //     \2 Set write position on LCD Line 2
16. //     \3 Set write position on LCD Line 3
17. //     \4 Set write position on LCD Line 4
18. //
19. //     lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1)
20. //
21. //-----------------------------------------------------------------------------
22. // LCD pins D0-D3 are not used.
23. //-----------------------------------------------------------------------------
24. //
25. // Commment   : Control of a compatible LCD HITACHI from a bus I2C with
26. //              an EXPANDER of I/O with connection I2C. The tests of these
27. //              routines have been programmed using the IC PCF8574T of Phillips.
28. //              I used 4 bits mode programming. The 8 bits mode programming
29. //              is possible if you use 2 x PCF8574T.
30. //
31. // As defined in the following structure the pin connection is as follows:
32. //
33. //  PCF8574P     LCD
34. //  ========     ======
35. //     P0        RS
36. //     P1        RW
37. //     P2        Enable
38. //     P3        Led Backlight
39. //     P4        D4
40. //     P5        D5
41. //     P6        D6
42. //     P7        D7
43. //
44. //  The SCL and SDA pins should be pull-up resistor as shown below:
45. //
46. //             +5v
47. //               |
48. //               <
49. //               > 4.7K      
50. //               <        
51. //To PIC         |          To i2c slave
52. //pin xx ------------------ SDA pin
53. //(SDA)                    
54. //              +5v
55. //               |
56. //               <
57. //               > 4.7K      
58. //               <        
59. //To PIC         |          To i2c slave
60. //pin xx ------------------ SCL pin
61. //(SCL)
62. //
63. //To PIC                    To i2c slave
64. //Vss pin ----------------- Vss or ground pin
65. //                |
66. //              -----
67. //               ---  Ground
68. //                -
69. //
70. // THIS DOCUMENT IS PROVIDED TO THE USER "AS IS"
71. //-----------------------------------------------------------------------------
72. //For PCF8574T the addressing is:
73.  
74. //Jp3 Jp2 Jp1
75. //A2 A1 A0  Hex
76. //L L L  0x40
77. //L L H  0x42
78. //L H L  0x44
79. //L H H  0x46
80. //H L L  0x48
81. //H L H  0x4A
82. //H H L  0x4C
83. //H H H  0x4E
84.  
85.  
86. /*    OJoooooooo            */
87.  
88. /*Para el PCF8574AT son estas direcciones:
89. //Jp3 Jp2 Jp1
90. //A2 A1 A0  Hex
91. //L L L  0x70
92. //L L H  0x72
93. //L H L  0x74
94. //L H H  0x76
95. //H L L  0x78
96. //H L H  0x7A
97. //H H L  0x7C
98. //H H H  0x7E
99.  */
100. // http://www.ccsinfo.com/forum/viewtopic.php?t=51351&start=24
101. //http://www.todopic.com.ar/foros/index.php?topic=13780.msg81633#msg81633
102. //----------------------------------------------------------------------------
103. extern void DelayMsec(unsigned int n_ms);
104.  
105. #define LCD_ADDR       0x7E //I2C slave address for LCD module El PCF8574AT y
106. //el PCF8574T tienen direcciones distintas.
107.  
108. #define ON             1
109. #define OFF            0
110. #define LCD_MODO_DATO      1
111. #define LCD_MODO_COMANDO   0
112. #define RS             0b00000001  //P0 - PCF8574T Pin connected to RS
113. #define RW             0b00000010  //P1 - PCF8574T Pin connected to RW
114. #define EN             0b00000100  //P2 - PCF8574T Pin connected to EN
115. #define BACKLIGHT_LED  0b00001000  //P3 - PCF8574T Pin connected to BACKLIGHT LED
116.  
117. #define lcd_line_one   0x80   // LCD RAM address for line 1
118. #define lcd_line_two   0xC0   // LCD RAM address for line 2
119. #define lcd_line_three 0x94   // LCD RAM address for line 3
120. #define lcd_line_four  0xD4   // LCD RAM address for line 4
121.  
122. bit lcd_backlight;
123.  
124. void i2c_send_nibble(unsigned char data) {
125.     StartI2C(); // begin I2C communications
126.     __delay_us(20);
127.     IdleI2C();
128.     WriteI2C(LCD_ADDR); // addresses the chip
129.     __delay_us(20);
130.     IdleI2C();
131.     WriteI2C(data);
132.     __delay_us(20);
133.     IdleI2C();
134.     StopI2C();
135.     __delay_us(20);
136. }
137.  
138. void lcd_send_byte(unsigned char data) {
139.     if (lcd_backlight) data = data | EN | BACKLIGHT_LED;
140.     else data = data | EN; //set pin EN
141.     i2c_send_nibble(data);
142.     data = data & 0B11111011; //toggle EN back to 0
143.     i2c_send_nibble(data);
144. }
145.  
146. void lcd_SendCommand(unsigned char command) {
147.     unsigned char data;
148.  
149.     data = command & 0xF0;
150.     lcd_send_byte(data);
151.     data = command & 0x0F;
152.     data = data << 4;
153.     lcd_send_byte(data);
154. }
155.  
156. void lcd_SendData(unsigned char in_data) {
157.     unsigned char data;
158.  
159.     data = in_data & 0xF0;
160.     data = data | RS; //set RS pin to 1
161.     lcd_send_byte(data);
162.     data = in_data & 0x0F;
163.     data = data << 4;
164.     data = data | RS; //set RS pin to 1
165.     lcd_send_byte(data);
166. }
167.  
168. void lcd_clear() {
169.     lcd_send_byte(0x00);
170.     lcd_send_byte(0x10);
171.     DelayMsec(12);
172. }
173.  
174. void lcd_init() {
175.     DelayMsec(200); //LCD power up delay
176.  
177.     //Request works on the command by set the RS = 0 R/W = 0 write
178.     lcd_send_byte(0x00);
179.     lcd_send_byte(0x10);
180.     lcd_send_byte(0x00);
181.     lcd_send_byte(0x00);
182.     lcd_send_byte(0x10);
183.     //First state in 8 bit mode
184.     lcd_send_byte(0x30);
185.     lcd_send_byte(0x30);
186.     //Then set to 4-bit mode
187.     lcd_send_byte(0x30);
188.     lcd_send_byte(0x20);
189.     //mode 4 bits, 2 lines, characters 5 x 7 (28 h)
190.     lcd_send_byte(0x20);
191.     lcd_send_byte(0x80);
192.     //no need cursor on (0Ch)
193.     lcd_send_byte(0x00);
194.     lcd_send_byte(0xC0);
195.     //the cursor moves to the left (06 h)
196.     lcd_send_byte(0x00);
197.     lcd_send_byte(0x60);
198.     //clears the display
199.     lcd_clear();
200. }
201.  
202. void lcd_gotoxy(unsigned char x, unsigned char y) {
203.     unsigned int address;
204.    
205.     switch (y) {
206.         case 1: address = lcd_line_one;
207.             break;
208.         case 2: address = lcd_line_two;
209.             break;
210.         case 3: address = lcd_line_three;
211.             break;
212.         case 4: address = lcd_line_four;
213.             break;
214.         default: address = lcd_line_one;
215.             break;
216.     }
217.  
218.     address += x - 1;
219.     lcd_SendCommand(address);
220. }
221.  
222. void i2c_lcd_backlight_On() {
223.     lcd_backlight = ON;
224. }
225.  
226. void i2c_lcd_backlight_Off() {
227.     lcd_backlight = OFF;
228. }
229.  
230. //Display the character on LCD screen.
231. void LCD_PUTC(char in_data) {
232.    
233.     switch (in_data) {
234.         case '\f': lcd_clear();
235.             break;
236.         case '\1': lcd_gotoxy(1, 1);
237.             break;
238.         case '\2': lcd_gotoxy(1, 2);
239.             break;
240.         case '\3': lcd_gotoxy(1, 3);
241.             break;
242.         case '\4': lcd_gotoxy(1, 4);
243.             break;
244.  
245.         default:
246.             lcd_SendData(in_data);
247.             break;
248.     }
249. }
250.  
251. void LCDprint(char * buff, unsigned char len) {
252.     unsigned char i;
253.     for (i = 0; i < len; i++) {
254.         LCD_PUTC(*(buff++));
255.     }
256. }

Y un ejemplito de uso:

Código: C

1. /**
2.   Generated Main Source File
3.  
4.   Company:
5.     Microchip Technology Inc.
6.  
7.   File Name:
8.     main.c
9.  
10.   Summary:
11.     This is the main file generated using MPLAB(c) Code Configurator
12.  
13.   Description:
14.     This header file provides implementations for driver APIs for all modules selected in the GUI.
15.     Generation Information :
16.         Product Revision  :  MPLAB(c) Code Configurator - 3.16
17.         Device            :  PIC18F26K80
18.         Driver Version    :  2.00
19.     The generated drivers are tested against the following:
20.         Compiler          :  XC8 1.35
21.         MPLAB             :  MPLAB X 3.20
22.  */
23.  
24. /*
25.     (c) 2016 Microchip Technology Inc. and its subsidiaries. You may use this
26.     software and any derivatives exclusively with Microchip products.
27.  
28.     THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
29.     EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED
30.     WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A
31.     PARTICULAR PURPOSE, OR ITS INTERACTION WITH MICROCHIP PRODUCTS, COMBINATION
32.     WITH ANY OTHER PRODUCTS, OR USE IN ANY APPLICATION.
33.  
34.     IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
35.     INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
36.     WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS
37.     BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE
38.     FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN
39.     ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
40.     THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
41.  
42.     MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE OF THESE
43.     TERMS.
44.  */
45.  
46. /*
47.  Referencias:
48.  *
49.  * http://www.studentcompanion.co.za/interfacing-the-ds1307-real-time-clock-with-pic-microcontroller-xc8/
50.  * http://www.ccsinfo.com/forum/viewtopic.php?t=51351&start=24
51.  * http://www.todopic.com.ar/foros/index.php?topic=13780.msg81633#msg81633
52.  */
53.  
54. //Se usa MCC para configurar el i2c y las "Peripheral Libraries",
55. //Hay que instalarlas en la carpeta de xc8
56. //descargando un instalador de Microchip, y
57. //activarlo en Project Properties, en xc8 linker.
58.  
59. #include <xc.h>
60. #include <stdio.h>
61. #include <string.h>
62. #include <math.h>
63.  
64. #include "mcc_generated_files/mcc.h"
65. #include "i2c_Flex_LCD.h"
66. #include "comun.h"
67.  
68. /*
69.                          Main application
70.  */
71. void main(void) {
72.     // Initialize the device
73.     SYSTEM_Initialize();
74.  
75.     //http://mikeyancey.com/hamcalc/lcd_characters.php
76.     unsigned char altavoz[8] = {0B00001, 0B00011, 0B11101, 0B10101, 0B11101, 0B00011, 0B00001, 0B00001};
77.     unsigned char bal_1[8] = {0B00000, 0B00000, 0B00001, 0B00001, 0B00001, 0B00001, 0B00000, 0B00000};
78.  
79.     lcd_init();
80.     i2c_lcd_backlight_On();
81.  
82.     // If using interrupts in PIC18 High/Low Priority Mode you need to enable the Global High and Low Interrupts
83.     // If using interrupts in PIC Mid-Range Compatibility Mode you need to enable the Global and Peripheral Interrupts
84.     // Use the following macros to:
85.  
86.     // Enable high priority global interrupts
87.     //INTERRUPT_GlobalInterruptHighEnable();
88.  
89.     // Enable low priority global interrupts.
90.     //INTERRUPT_GlobalInterruptLowEnable();
91.  
92.     // Disable high priority global interrupts
93.     //INTERRUPT_GlobalInterruptHighDisable();
94.  
95.     // Disable low priority global interrupts.
96.     //INTERRUPT_GlobalInterruptLowDisable();
97.  
98.     // Enable the Global Interrupts
99.     //INTERRUPT_GlobalInterruptEnable();
100.  
101.     // Enable the Peripheral Interrupts
102.     //INTERRUPT_PeripheralInterruptEnable();
103.  
104.     // Disable the Global Interrupts
105.     //INTERRUPT_GlobalInterruptDisable();
106.  
107.     // Disable the Peripheral Interrupts
108.     //INTERRUPT_PeripheralInterruptDisable();
109.    
110.     for (uint8_t i = 0; i < 8; i++) {
111.         lcd_SendCommand(0x40+i);
112.         lcd_SendData(altavoz[i]);
113.         lcd_SendCommand(0x48+i);
114.         lcd_SendData(bal_1[i]);
115.     }
116.    
117.     lcd_gotoxy(5, 1);
118.     lcd_SendData(0);
119.     lcd_SendData(1);
120.  
121.     while (1) {
122.         lcd_gotoxy(1, 2);
123.         LCDprint("Hola mundo!!! 1", 15);
124.         DelayMsec(200);
125.     }
126. }
127. /**
128.  End of File
129.  */

Para configurar el bus i2c he usado el plugin MCC, y luego he instalado las "Peripheral Libraries".

Un saludo!!!

[KILLERJC]

Si vas a usar strings con esto:

Código: C

1. void LCDprint(char * buff, unsigned char len) {
2.     unsigned char i;
3.     for (i = 0; i < len; i++) {
4.         LCD_PUTC(*(buff++));
5.     }
6. }

Le podes quitar la parte del len, asi no tenes que saber exactamente cuanto estas enviando.

Código: C

1. void LCDprint(char * buff) {
2.     while(*buff)
3.     {
4.         LCD_PUTC(*(buff));
5.         buff++;
6.     }
7. }

Pero de tu forma al menos podes limitar si o si a 15 caracteres, o aca dentro del while limitarlo tambien a 15. De esa forma nunca supera la linea.Algo asi:

Código: C

1. #DEFINE LCD_MAX_LENGTH  15
2.  
3. void LCDprint(char * buff) {
4.         short int i = 0;
5.     while(*buff && i != LCD_MAX_LENGTH)
6.     {
7.         LCD_PUTC(*buff);
8.         buff++;
9.         i++;
10.     }
11. }

[micro_pepe]

Lo que hago a la hora de llamar a la función, es lo siguiente:

Código: C

1. LCDprint(texto, sizeof(texto));

Si el texto es una constante lo asigno primero a una cadena, la forma que dices de hacerlo con un while, la probé hace tiempo en otro proyecto y me daba problemas, a veces aparecian caracteres en el LCD durante un segundo y desaparecian, haciendo la rutina como la tengo se solucionó el problema.

Gracias!!! Un saludo.

[KILLERJC]

Claro, pero esto no te sirve para cosas asi:

Código: C

1. LCDprint("Hola mundo!!! 1");

Las cuales tendrias que contar 1 por 1 el valor. Y que pienso que es lo mas practico la mayoria de las veces.
En si el while no deberia provocarte eso para nada. Ya que funcionaria de la misma forma que tu anterior codigo nomas que ahora para al llegar al '\0'. Tal ves tenias otro problema antes.

[micro_pepe]

Claro, pero esto no te sirve para cosas asi:

Código: C

1. LCDprint("Hola mundo!!! 1");

Las cuales tendrias que contar 1 por 1 el valor. Y que pienso que es lo mas practico la mayoria de las veces.
En si el while no deberia provocarte eso para nada. Ya que funcionaria de la misma forma que tu anterior codigo nomas que ahora para al llegar al '\0'. Tal ves tenias otro problema antes.

OK, lo probaré como dices.

Gracias!!! Un saludo.