Puntero a matriz constante

[Diego E.]

Hola amigos, conocen alguna forma en CCS para apuntar a una matriz constante ?

Código: C

1. int const tab_grafico1[] = {0xff,0xff,
2.                                                         0xff,0xff,
3.                                                         0xc0,0x0f,
4.                                                         0xc0,0x0f,
5.                                                         0xc0,0x0f,
6.                                                         0xcf,0xcf,
7.                                                         0xcc,0xcf,
8.                                                         0xfc,0xff,
9.                                                         0xfc,0xff,
10.                                                         0xfc,0xc3,
11.                                                         0xfc,0xc3,
12.                                                         0x84,0xdb,
13.                                                         0x84,0xdb,
14.                                                         0xfc,0xc3,
15.                                                         0xfc,0xc3,
16.                                                         0xfc,0xff};

dir_tabla = &tab_grafico1[0]; esto me presenta error

Muchas gracias

[jukinch]

Hola Diego:
        No uso ccs. Pero que error te da?
             

[Diego E.]

Hola jukinch, aparece "Expecting an identifier", pero si hago lo mismo con una variable de RAM si funciona

dir_tabla = &variable[0];

[RALF2]

Diego E.
Revisa amigo aqui a ver si te sirve   
La clave esta en la rom 

Saludos

[Diego E.]

Hola Ralf2, efectivamente de esta forma funciona, la clave está en la ROM, lo definí así

char rom tabla[] = "0123456789";
char rom *dir_tabla;

//realizar un barrido

int i;

dir_tabla = tabla;
for(i=0;i<=sizeof(tabla);i++)
{
   status = *dir_tabla + i;
}

Muchas gracias, Saludos

[RALF2]

De nada Diego E. 
Te recominedo tambien que le heches una mirada al manual de CCS (22-jun-12) creo que a partir de la pagina 50, aparece explicado tambien lo del uso de la rom para guardar datos y como estos pueden ser direccionados por punteros! 

Saludos

[BrunoF]

Hola Diego,

hasta el momento CCS NO SOPORTA punteros a constantes ni a funciones.

Attempt to create a pointer to a constant
Constant tables are implemented as functions.   Pointers cannot be created to functions.  For example CHAR CONST MSG[9]={"HI THERE"}; is permitted, however you cannot use &MSG.  You can only reference MSG with subscripts such as MSG and in some function calls such as Printf and STRCPY.


Es una gran restricción del CCS.

[Diego E.]

Hola Bruno, sucede algo muy extraño, en el ejemplo que puse arriba con la directiva ROM puedo hacer el barrido por toda la tabla, pero lo aplico en otra rutina y ya no funciona, lee valores errados.

Código: CSS

1. //puntero para leer tablas
2. char rom *dir_tabla;
3. //16 lineas, 2 columnas
4. char rom tab_grafico1[] = {0xff,0xff,
5.                                                         0xff,0xff,
6.                                                         0xc0,0x0f,
7.                                                         0xc0,0x0f,
8.                                                         0xc0,0x0f,
9.                                                         0xcf,0xcf,
10.                                                         0xcc,0xcf,
11.                                                         0xfc,0xff,
12.                                                         0xfc,0xff,
13.                                                         0xfc,0xc3,
14.                                                         0xfc,0xc3,
15.                                                         0x84,0xdb,
16.                                                         0x84,0xdb,
17.                                                         0xfc,0xc3,
18.                                                         0xfc,0xc3,
19.                                                         0xfc,0xff};
20.  
21. void grafico(int y, x, filas, columnas);
22.  
23.  
24. //se carga el puntero de la tabla a presentar
25. dir_tabla = &tab_grafico1[0];
26.  
27. //y,x,filas,columnas
28. grafico(1,1,16,2);
29.  
30. ///////////////////////////////////////////////////////////////////////////////
31. //realiza un barrido de filas y columnas copiando la tabla de constantes
32. void grafico(int y, x, filas, columnas)
33. {
34.         int i1, i2;
35.         int registro = 0;
36.        
37.         for(i1=0;i1<filas;i1++)
38.         {
39.                 situar_cursor(y + i1,x);
40.                
41.                 for(i2=0;i2<columnas;i2++)
42.                 {
43.                         enviar_octeto(*dir_tabla + registro);
44.                         registro++;
45.                 }
46.         }
47. }

No aparece error al compilar pero lee dato errados.

Saludos.

[RALF2]

pero lo aplico en otra rutina y ya no funciona, lee valores errados

A que te refieres "con a otra rutina" Diego E.?

Yo se que en versiones anteriores del CCS, no permitia punteros a ROM, pero si te funciono quiere decir que ahora si se puede?

Yo no he probado aun colocar constantes en ron y luego direccionarlas con punteros, por que estoy ocupado pero apenas tenga un chance lo probare para ver que sucede  

[MGLSOFT]

Tengo idea que ahora si se puede, desde hace dos o tres versiones...

[Diego E.]

Hola amigos, he probado con esta rutina y lee bien la primera dirección de la tabla luego continúa trayendo datos secuenciales,

Código: CSS

1. #include <16f876A.h>
2.  
3. #use delay(clock=4mhz)
4. #fuses xt,put,brownout,nowdt
5.  
6. #byte   porta=5         //Definicion de variables del pic
7. #byte   portb=6
8. #byte   portc=7
9.  
10. #define port_lcd portb
11.  
12. int status;
13.  
14. char rom *dir_tabla_g;
15. char rom tab_grafico1[] = {     0xff,0xff,
16.                                                         0xff,0xff,
17.                                                         0xc0,0x0f,
18.                                                         0xc0,0x0f,
19.                                                         0xc0,0x0f,
20.                                                         0xcf,0xcf,
21.                                                         0xcc,0xcf,
22.                                                         0xfc,0xff,
23.                                                         0xfc,0xff,
24.                                                         0xfc,0xc3,
25.                                                         0xfc,0xc3,
26.                                                         0x84,0xdb,
27.                                                         0x84,0xdb,
28.                                                         0xfc,0xc3,
29.                                                         0xfc,0xc3,
30.                                                         0xfc,0xff};
31.  
32. void grafico(int y, x, filas, columnas);
33.  
34. ///////////////////////////////////////////////////////////////////////////////
35. ///////////////////////////////////////////////////////////////////////////////
36. #zero_ram       //Borrado de la memoria ram
37.  
38. void main()             //Rutina principal
39. {
40. set_tris_a(0b000000);           //Configuracion de entradas y salidas del puerto A
41. set_tris_b(0b00000000);         //Configuracion de entradas y salidas del puerto B
42. //port_b_pullups(true);         //Habilitación de las resistencias pull-ups
43. porta = 0xff;
44. portb = 0;
45. ///////////////////////////////////////////////////////////////////////////////
46. //se carga el puntero de la tabla a presentar
47. dir_tabla_g = &tab_grafico1[0];
48.  
49. //y,x,filas,columnas
50. grafico(1,1,16,2);
51. ///////////////////////////////////////////////////////////////////////////////
52. while(true)             //Rutina general
53.         {
54.        
55.         }
56. }
57. ///////////////////////////////////////////////////////////////////////////////
58. //realiza un barrido de filas y columnas copiando la tabla de constantes
59. void grafico(int y, x, filas, columnas)
60. {
61.         int i1, i2;
62.         int registro = 0;
63.        
64.         for(i1=0;i1<filas;i1++)
65.         {
66.                
67.                 for(i2=0;i2<columnas;i2++)
68.                 {
69.                         status = *dir_tabla_g + registro;
70.                         registro++;
71.                 }
72.         }
73. }      
74. ///////////////////////////////////////////////////////////////////////////////

[Diego E.]

Hola, de esta forma si me funcionan los puntero a constantes

Código: CSS

1. char rom *dir_tabla_g;
2. char rom tabla1[] = {0x01,0x80,0x03,0xc0,0x7f,0xfe,0x7f,0xfe,0x21,0x84,0x21,0x84,0x51,0x8a,0x89,0x91,0xf9,0x9f,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x03,0xc0,0x3f,0xfc,};
3.  
4. dir_tabla_g = tabla1;

Código: CSS

1. void grafico(int y, x, filas, columnas)
2. {
3.         int i1, i2;
4.         int registro = 0;
5.        
6.         for(i1=0;i1<filas;i1++)
7.         {
8.                
9.                 for(i2=0;i2<columnas;i2++)
10.                 {
11.                         status = *(dir_tabla_g + registro);
12.                         registro++;
13.                 }
14.         }
15. }

Saludos

[Diego E.]

Hola amigos, de esta forma me funciona perfecto el puntero a constantes, pero ahora necesito llevar un puntero a tablas, alguno de ustedes tiene una idea de como hacerlo ?

Muchas gracias.

Código: CSS

1. int variable;
2.  
3. char rom *dir_tabla;
4.  
5. char rom c_30[] = {0x3c,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x3c,0x00,0x00,0x00,};
6. char rom c_31[] = {0x08,0x38,0x08,0x08,0x08,0x08,0x08,0x08,0x7f,0x00,0x00,0x00,};
7. char rom c_32[] = {0x3c,0x42,0x42,0x04,0x08,0x10,0x20,0x42,0x7e,0x00,0x00,0x00,};
8. char rom c_33[] = {0x3c,0x42,0x02,0x02,0x0c,0x02,0x02,0x42,0x3c,0x00,0x00,0x00,};
9. char rom c_34[] = {0x0c,0x14,0x14,0x24,0x24,0x7e,0x04,0x04,0x1e,0x00,0x00,0x00,};
10. char rom c_35[] = {0x3e,0x20,0x20,0x3c,0x02,0x02,0x02,0x42,0x3c,0x00,0x00,0x00,};
11.  
12.  
13. dir_tabla = c_30;
14. grafico1();
15.  
16. void grafico1()
17. {
18.    int registro;
19.    
20.    for(registro = 0; registro<12;registro++)
21.    {
22.       variable = *(dir_tabla + registro);
23.    }
24. }

[Diego E.]

Después de lidiar mucho tiempo solo con este tema logré que me funcionaran los punteros a constantes y los punteros a tablas de constantes.

Lo comparto porque me parece demasiado útil para optimizar programas de gráficos, etc.

Código: CSS

1. #include <18f2550.h>
2.  
3. #use delay(clock=4mhz)
4.  
5. #fuses xtpll,nomclr,nowdt,noprotect,nolvp,nodebug,usbdiv,pll1,cpudiv1,vregen,nopbaden
6.  
7.  
8. int variable;
9.  
10. //se define la variable puntero rom
11. char rom *dir_tabla;
12.  
13. char rom c_30[] = {1,2,4,8,16,32,64};
14. char rom c_31[] = {2,4,6,8,8,10,12};
15. char rom c_32[] = {3,6,9,12,15,18,21};
16. char rom c_33[] = {4,4,12,16,20,24,28};
17. char rom c_34[] = {5,10,15,20,25,30,35};
18. char rom c_35[] = {6,12,18,24,30,36,42};
19.  
20. //matriz que hace referencia a las tablas
21. char rom letras[] = {c_30,c_31,c_32,c_33,c_34,c_35,};
22.  
23. void rutina1();
24.  
25. ///////////////////////////////////////////////////////////////////////////////
26. ///////////////////////////////////////////////////////////////////////////////
27. #zero_ram       //Borrado de la memoria ram
28.  
29. void main()             //Rutina principal
30. {
31. //opcion1: se carga el puntero de la tabla a presentar
32. dir_tabla = c_30;
33. rutina1();
34.  
35. //opcion 2: se elige que tabla se va a presentar de acuerdo a la matriz de referencias
36. dir_tabla = letras[4];
37. rutina1();
38.  
39. ///////////////////////////////////////////////////////////////////////////////
40. while(true)             //Rutina general
41.         {
42.        
43.         }
44. }
45. ///////////////////////////////////////////////////////////////////////////////
46. //realiza un barrido de filas y columnas copiando la tabla de constantes
47. void rutina1()
48. {
49.         int registro;
50.        
51.         for(registro = 0; registro<7; registro++)
52.         {
53.                 variable = *(dir_tabla + registro);
54.         }
55. }      
56. ///////////////////////////////////////////////////////////////////////////////