uso de funcion putsXLCD() C18

[PICYO]

esta por mil foros pero no soy capaz de sacar una conclusión.
Cuando uso la funcion de escritura ( de C18)  putrsXLCD("); todo va perfecto, pero lo intersante es que en funcion de un índice, acceder a un array.
Tengo unas frases de este tipo :

Código: C

1. char rom * Menu[]={ "Opcion 1 ",
2.                                         "Opcion 2",
3.                                         NULL
4.                                        
5. };

y ya en main(), tengo esta escritura:

Código: C

1. case   1: LATAbits.LATA0=0;
2.                      clearDisplay()      ;
3.                      Delay10KTCYx(10);                
4.                      putsXLCD(Menu[0]);
5.                      Delay10KTCYx(200);
6.                      putrsXLCD("esta frase=mala");
7.                      break;

Cuando pulso un pulsador ( valga la redundancia), pongo LATAbits.LATA0=0; para apagar un led, y comprobar que entra en esa parte de programa. Otro modo de comprobarlo, es cuando pongo putrsXLCD("esta frase=mala");, que quiero decir que si, sale mensaje por LCD pero no de la forma que yo quiero. Quiero usar putsXLCD(Menu[0]);, para que si tecleo ese pulsador, salga ESA farse del menu.

Pero al iniciar la simulacion, lo que pasa es..NAda ( si que sale la frase de  putrsXLCD("esta frase=mala")
Haciendo rpuyebas, y viendo como lo usa la gente por aqui, veo que usan la frase sin índice, es decir, solo es un simple string. Yo quiero usarlo en un array, y se que he de poner un puntero como índice... pero ahí resta todo. He hecho mil pruebas y no me salgo con la mía. ¿ Cómo he de hacerlo pues?!

[Suky]

El problema es que creas un array en rom pero utilizas la función para escribir un array en ram    Debes hacer putrsXLCD(Menu[0]), putrsXLCD(Menu[1]), ect...



Saludos!

[PICYO]

ups..pues si.. era tan sólo eso! La verdad, como usaba esa misma función entrecomillando el argumento ( pasando la frase directamente) no creía que debiera ser asi.

Ademas, eso del puntero me rondaba por la cabeza, porque he visto un menu para GLCD que es a base de punteros, y me pareció perfecto para aprender acerca de éstos, aunque he de subir " nivel " para entender aquel programa de menú para GLCD ( lo trataba de adaptar para un simple LCD). Seguro que ese programa te suena, Suky
Grácias!

[Suky]

jejeje! Cualquier duda la comentas, si está a mi alcance intentaré responderla. Aunque para un LCD yo haria una estructura así:

Código: C

1. typedef struct{
2.      char TipoMenu;
3.      rom char *PtrTextoItem;
4.      rom char *PtrFuncionMenu;
5. }MENU;

Y luego crear un menu, por ejemplo:

Código: C

1. void vInicializaSistemaDisplay(void);
2. void vControlBack(void);
3. rom MENU SubMenu1[];
4.  
5. rom MENU MenuPrincipal[]={
6. {MENU_MAIN,"",vInicializaSistemaDisplay},
7. {MENU_SUBMENU,"Sub Menu",SubMenu1},
8. {MENU_COMANDO,"Backlight",vControlBack},
9. {MENU_FIN,"",0}
10. };

Lee el siguiente articulo, puede ayudar a entender como es la estructura de la librería:

http://www.micros-designs.com.ar/como-crear-menus-en-lcd/

Saludos!

[PICYO]

Uhm, muy bueno ese  link! Lo que quizás primero he de hacer que me funcione el "fácil" antes de meterme en ese otro ( que sin duda, lo haré). Estoy haciendo un menu diferente, la idea la he cojido también de algún hilo de por aqui ( creo..no recuerdo). La cosa es tener dos funciones, una que escanee la tecla ( o pulsador en este caso) pulsada.

Esa tecla pulsada, iria a otra función la cual incrementaria, o decrementaria un contador, en funcion de la tecla "+" o "-" pulsada. Esty de momento en este punto que no hago funcionar ( es una idiotez, pero no entiendo por qué no funciona). Una vez vea que el contador incrementa / decrementa bien al pulsar + o -, otra funcion que se dedique a ejecutar "x" funciones, en caso que reciba la tecla ( valor) OK.

Bien, pues estoy en la parte del contador. hago una prueba, que si el contador (posicionActual en el main) es mas grande de uno, se apague el led. Y aqui viene el primero de los POr quee?..si pulso tecla menos, ese contador lo que deberia hacer es decrementar hasta un valor maximo de 0...deberia tener siempre el valor de 0..por que se me apaga el led pues? Por que al pulsar "tecla -" incrementa el pulsador ?

Código: C

1. //main menu en LCD 2x16
2. #define UPPER
3. #include <p18f4550.h>
4. #include <p18cxxx.h>
5. #include <stdio.h>
6. #include <xlcd.h>
7. #include <delays.h>
8. #include <stdlib.h>
9. #include "menu.h"
10.  
11.  
12.  
13. ///////// configuracion fuses ///////////////////////////////////////////////////////////////////
14. #pragma config FOSC = HS
15. #pragma config CPUDIV = OSC1_PLL2
16. #pragma config VREGEN = OFF //Disabled  USB power
17. #pragma config WDT = OFF// HW Disabled - SW Controlled  
18. ///////////////////////////////////////////////////////////////////////////////////////////////
19.  
20.  
21.  
22. /////////// PROTOTIPO FUNCIONES PARA DELAYS y XLCD /////////////
23. void DelayFor18TCY(void){  // TCY=4/Frec.Trabajo
24.         Delay10TCYx(2);        // Mi TCY para F_trabajo=4MHz es de 1mS. El retardo que piden será pues de 18*TCY=18mS
25. }                          // 10*x*(4/4MHz)=18uS; aislamos x, y x=1,8, por eso se pone 2. Seria algo mas de 18 TCY.
26.  
27.  
28. void DelayPORXLCD(void){
29.         //Delay1KTCYx(15);       // 1000*15*(4/4MHz)= 0,015 s
30.       Delay1KTCYx(18);
31. }
32. void DelayXLCD(void){
33.         Delay1KTCYx(2);        // 1000*2*(4/4MHz)= 0,002 s
34. }
35. // Envia comando al LCD
36. void comandXLCD(unsigned char a){
37.         BusyXLCD();            
38.         WriteCmdXLCD(a);
39. }
40. // Ubica cursor en (x = Posicion en linea, y = nº de linea)
41. void gotoxyXLCD(unsigned char x, unsigned char y){
42.         unsigned char direccion;
43.  
44.         if(y != 1)
45.                 direccion = 0x40;
46.         else
47.                 direccion=0;
48.        
49.         direccion += x-1;
50.         comandXLCD(0x80 | direccion);
51. }
52. void clearDisplay(void){
53. /*
54. Instruction      RS RW: DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0     (Description fOSC is 270 kHz)
55. Clear display
56.                  0   0   0    0   0   0   0   0   0  1        Clears entire display and sets
57. DDRAM address 0 in addresscounter.*/
58. BusyXLCD();    
59. WriteCmdXLCD(0b0000000001);
60. Delay10TCYx(10);
61. gotoxyXLCD(1,1);
62. }
63.  
64.  
65.  char rom * Menu[]={ "Opcion 1  ",
66.                                         "Opcion 2",
67.                                         NULL
68.                                        
69. };
70.  
71.  
72. char rom * SubMenu1[]={ "SubMenu1-1","SubMenu1-2","SubMenu1-3","SubMenu1-4","SubMenu1-5","SubMenu1-6",
73.                                                 "SubMenu1-7","SubMenu1-8","SubMenu1-9","SubMenu1-10",
74.                                              NULL
75. };
76. char rom *fraseComun={"OK?"};
77.  
78.  
79. void presentacion(void);
80. void test_pantalla(void);
81. void parpadeo(void);
82. int PosicionaMenu(int EscTecla,int posicion);
83.  
84. ///////////////////////////////////
85. ///////////////////////////////////////
86. ///////////////////////////////////
87.  
88. void main(void){
89.  
90.  
91. int  EscTecla=0,PosicionInicial=0,posicionActual=0;
92.  
93.  
94. ADCON1=0xFF;
95. TRISA = 0b10111110;  //Define todos los puertos A como pines de entrada/salida.
96. OpenXLCD(FOUR_BIT & LINES_5X7); // Iniciamos LCD.-
97. //test_pantalla();
98. //presentacion();
99. LATAbits.LATA0=1;
100. //OpenXLCD(PARAM_SCLASS unsigned char);
101. while(1){
102.    
103.     EscTecla=Teclado();
104.     Delay10KTCYx(20);  
105.     posicionActual=PosicionaMenu(EscTecla,PosicionInicial);
106.     Delay10KTCYx(20);
107.     if (posicionActual>1){
108.     LATAbits.LATA0=0;
109.    }
110.     /*
111.         switch (EscTecla){    //MIRAR PQ ESCTECLA TOMA VALORES MAYORES DE 5. Con variable co0mo int si hace toma               
112.         case   0:parpadeo();
113.             break;
114.         case   1:
115.                                 LATAbits.LATA0=0; // valores normales. Con enum no.                        
116.                
117.  
118.  
119.                                            
120.                 break;
121.                 case   2:
122.                                 LATAbits.LATA0=0;
123.                                 clearDisplay()   ;
124.                                 Delay10KTCYx(10);                              
125.                
126.                 break;
127.                
128.        }  */
129.        
130.  }
131.  
132. }
133.  
134.  
135.  
136.  
137.  
138.  
139. void presentacion(){
140. comandXLCD(0x06); // Nos aseguramos incremento de direccion, display fijo
141. comandXLCD(0x0C);                       // Encendemos LCD.-
142. gotoxyXLCD(1,1);
143. putrsXLCD("Elije menu");
144. Delay10TCYx(10);
145. gotoxyXLCD(1,2);                        //Pasamos al oriden del Linea 2.-
146. putrsXLCD("y pulsa OK");
147. Delay10TCYx(20);
148. }
149.  
150. void test_pantalla(){
151. comandXLCD(0x06); // Nos aseguramos incremento de direccion, display fijo
152. comandXLCD(0x0C);                       // Encendemos LCD.-
153. gotoxyXLCD(1,1);
154. putrsXLCD("abcdefghijklmnño");
155. Delay10TCYx(10);
156. gotoxyXLCD(1,2);                        //Pasamos al oriden del Linea 2.-
157. putrsXLCD("Total:16 ");
158. Delay10TCYx(20);
159. }
160.  
161. void parpadeo(void){
162.         LATAbits.LATA0=0;
163.     Delay10KTCYx(20);
164.         LATAbits.LATA0=1;
165.     LATAbits.LATA0=0;
166.     Delay10KTCYx(20);
167.         LATAbits.LATA0=1;
168. }
169.  
170. int PosicionaMenu(int EscTecla,int PosicionInicial){
171.  
172. int pos;
173. pos=PosicionInicial;
174.  
175.         if ( !pulsador_MenuMas) {
176.                 Delay10KTCYx(100);
177.             pos++;
178.         }
179.        
180.         if (!pulsador_MenuMenos){
181.             Delay10KTCYx(10);
182.                 pos--;
183.                 comandXLCD(0x06); // Nos aseguramos incremento de direccion, display fijo
184.                 comandXLCD(0x0C);                       // Encendemos LCD.-
185.                 gotoxyXLCD(1,1);
186.                 putrsXLCD("tecla -");
187.                 Delay10TCYx(10);
188.         if (pos<=1){pos=0;}
189.         return pos;
190.         }
191.        
192.         if (!TeclaOk){
193.             Delay10KTCYx(10);
194.                 return pos;
195.         }
196.  
197.  
198. }

Código: C

1. #include "menu.h"
2. #include <stdio.h>   // entre otras cosas...necesaria para palabra NULL
3.  
4.  
5. char rom * SubMenu1interno[]={ "SubMenu1-1","SubMenu1-2","SubMenu1-3","SubMenu1-4","SubMenu1-5","SubMenu1-6",
6.                                                 "SubMenu1-7","SubMenu1-8","SubMenu1-9","SubMenu1-10"};
7.  
8.  
9. char rom * MenuInterno[]={ "Opcion 1  ",
10.                                         "Opcion 2",
11.                                         NULL
12.                                        
13. };
14.  
15. int Teclado ( void )
16. {
17. //      enum teclas tecla = TeclaNada;
18.     int tecla = TeclaNada;
19.         char temp_tris;
20.     unsigned int contadorMaS=0,contadorMenos=0;
21.        
22.         if ( !pulsador_MenuMas) {
23.         Delay10KTCYx(10);
24.         contadorMaS++;
25.                 if ( contadorMaS > 1)
26.                         contadorMaS=0;
27.                         tecla=TeclaMas;                                        
28.     }
29.         else {
30.          tecla=TeclaNada;
31.    }
32.  
33.  
34.         if (!pulsador_MenuMenos){
35.     Delay10KTCYx(10);
36.         contadorMenos++;
37.                 if (contadorMenos<=1){
38.                         //contadorMaS=1;
39.                         tecla=TeclaMenos;
40.                 }
41.         else{
42.                         tecla=TeclaNada;
43.                 }
44.  
45.  
46. }
47.    
48. return tecla;
49. }

[PICYO]

ah, olvidaba decir algo mas... para ver que valor toma  "posicionActual", hago debugg en el Proteus, pero nunca me aparece esta variable en el listado ..¿ por que ?

[Suky]

ah, olvidaba decir algo mas... para ver que valor toma  "posicionActual", hago debugg en el Proteus, pero nunca me aparece esta variable en el listado ..¿ por que ?

Colocala como variable global, sino tienes que estar dentro de la funcion para verla desde Proteus.

Saludos!

[PICYO]

DIOSS!!! Siempre he creído que variable global ya se entendia como cualquier  variable dentro del main(), sin entrar en ninguina función ..El main() no es mas que otra función más realmente! ( Eso se ve mas claro en Visual C++, que la cabezera está lleeena de parámtros). Mal no haberlo sabido, pero peor no haberlo remediado ( grácias!).
Bien, ahora si soy capaz de ver la variable, que por otra parte, ya he " medio arreglado". Ese valor negativo ya no lo toma, me equivoqué al pasar un retunr en la función PosicionaMenu(), deberia ser esto :

Código: C

1. if (!pulsador_MenuMenos){
2.             Delay10KTCYx(100);
3.                 pos--;      
4.                 comandXLCD(0x06); // Nos aseguramos incremento de direccion, display fijo
5.                 comandXLCD(0x0C);                       // Encendemos LCD.-
6.                 gotoxyXLCD(1,1);
7.                 putrsXLCD("tecla -");
8.                 Delay10TCYx(10);
9.         if (pos<1){pos=0;}
10.         return pos;
11.         }

Ahora he de arreglar que solo me cuente hasta 1, pero ya no doy "palos de ciego" ! Merci!

[PICYO]

me empiezo a rendir ya con esto del C.
Como puedo hacer para que la funcion actualize posicionActual, con la funcion PosicionaMenu(x,y) ? La verdad es que quiero uasr un puntero ( he de aprender punteros ya de una vez).
Quiero que ese puntero -"pposicionActual" apunte a una variable global "posicionActual".

La unica forma que he conseguido lograr mi objetivo (al pulsar tecla+ que incremente en uno posicionActual) es directamente :

Código: C

1. if ( !pulsador_MenuMas) {
2.                 Delay10KTCYx(10);
3.                 posicionActual++;
4.     }

Pero vamos, quiero usar punteros ( esa funcion la quiero pasar a otro archivo.c) y hacer une " mega" main x...

[Suky]

mmm... para usar punteros, en alguna funcion de inicialización inicias el puntero para que apunte a la variable:

pposicionActual=&posicionActual;

Y despues trabajas con el puntero:

pposicionActual++;

pposicionActual--;

ect, pero no se si tendrá alguna utilidad esto ultimo 


Saludos!

[PICYO]

Bueno ya lo habia probado asi, solo que directamente sin el simbolo &
(pposicionActual=posicionActual)

Claro, no tiene sentido hacer esto, porque lo que veo que incrementa es una dirección ( la del puntero) que bien poco me importa a mi. Lo que quiero es que a lo que apunta ese puntero, quede incrementado. El por que de quierer usar punteros es que no se bien cuantas veces he de usar eso, y en cuantas funciones, asi que lo que quiero es pasar a una función el valor actual "posicionActual" mediante el puntero "pposicionActual", para que éste , a su vez, modifique globalmente  la variable en uno.

Código: [Seleccionar]

Y he hecho varias pruebas de prototipos de funcion, desde que se le pasa por parámetros ese "pposicionActual" por ejemplo, ( los escribier de memoria)

1)
[code=c]
/// Prototipo de funcion y declaracion. En esta pretendia  desde parametros, pasar el puntero  con la posicionActual

int Funcion1 ( int tecla, int *pposicionActual){

int auxiliar; //declaro esta auxiliar, pq no estaba seguro de poder operar directamente los valores ( incrementar) con parametro
auxiliar=*pposicionActual;  // quiero que auxiliar tome el valor de lo que apunta en ese momento pposicionActual
 if ( !pulsador_MenuMas) {
Delay10KTCYx(10);        
       auxiliar++;    // auxiliar tendría un valor pasado ( segun mi ¿eh ?) por la funcion, y el parameytro de ella, al valor actual ( recojido en main) de posicionActual
                
    }

 return auxiliar;
}



// (....) habria unas lineas de programa
// y ahora hago esto que me decias:


posicionActual=0; // inicializo a 0
int * pposicionActual; // creo el puntero
pposicionActual=posicionActual // aqui esta lo que me dices. Quiero que ese puntero apunte a la variable entera posicionActual, para que ésta sea modificada                 //                                                //indirectamente por "x" funciones y se refleje globalmente su cambio



// ( ...)
int auxiliar2=0; //creo esta auxiliar ya en el  programa principal (antes del main)
//(...)
auxiliar2 = Funcion1 ( tecla, *pposicionActual);   // como le paso el puntero, no se si puedo igualar el puntero y parametrizarlo con él mismo,
//                                                                             asi que lo hago un poco mas             "largo"
*pposicionActual=auxiliar2;

Si esta funcion hubiese funcionado, quiere decir que entiendo al 80 % el concepto y uso de los punteros, pero...uf no. Mal. Se me ocurrio otra "estupenda" idea:



2) hacer que directamente devuelva un puntero..EL puntero mas bien.
/// Prototipo de funcion y declaracion. En esta pretendia  desde parametros, pasar el puntero  con la posicionActual

Código: C

1. int * Funcion2 ( int tecla, int *pposicionActual){
2.  
3.  if ( !pulsador_MenuMas) {
4.                 Delay10KTCYx(10);        
5.                 *pposicionActual++;   / / Ahora quiero que se quede incrementado el contenido de la direccion donde apunta ese puntero
6.                                                    // o sea, la variable posicionActual, directamente
7.                
8.     }
9.  
10.  return *pposicionActual;
11. }
12.  
13.  
14.  
15. // (....)
16.  
17.  
18. posicionActual=0; // inicializo a 0
19. int * pposicionActual; // creo el puntero
20. pposicionActual=posicionActual // Quiero que ese puntero apunte a la variable entera posicionActual                                                        
21. //(...)
22. *pposicionActual= Funcion1 ( tecla, *pposicionActual);   // fuera miedo ya ver que pasaba haciendo esto

Me daba errores, creo que los solvente, y el resultado es que siempre se modifica la dioreccion del puntero, pero ...

                                -|
*pposicionActual++  |
                                 |
                                 |-->  para mi la diferencia entre ambas, es que una incrementa la direccion del puntero ( no importa ya la variable donde apuntaba)
pposicionActual++    |       y la otra no modiofica la direccion, pero si el contenido , o sea, la variable posicionActual ( la primera de ellas, con el *)
                                -|

Y no... sólo me sale lo que quiero si prescindo de punteros ( que no quiero) e incluso de usar  funciones ( un if a "saco" en el main ( cosa que tampoco quiero)

[/code]

[PICYO]

uyy de casualidad ( he probado hacer una cosa que me parecia obvia...) he cambiado esto :


1) *pposicionActual++;


                por

2) *pposicionActual=*pposicionActual+1;


Y es lo msimo , ¿ no? Pues...¡ Nooo!
Bueno, cuando lo ves..pues eso..lo ves. Los punteros son como los arrays ( al rebés). Con la primera sentencia ( entiendo que es asi ) lo que haces es :

1) array(i)=>array(i+1);
Mientras que con la segunda, lo que se hace es
2) array(i)=> array(i)+1

Bueno no se si lo he explicado bien, pero esa es la deducción que saco ...

 Aunque hacer la funcion de eso... no entiendo como he de psar los parametros a la funcion ( si he de hacer caso 1, caso 2  u otro caso). He arreglado la cuestion del puntero ( que no esta mal) poero ahora me falta el pasar correctamente los parametros de la funcion, que no me salgo con ello...

[PICYO]

Bueno, yo me contesto..otra vez, he hecho algo que creía que no tendria relevancia ( cuando piensas mil cosas y te fastidia darte por vencido). Es a la hora de pasar valores a la funcion. Siempre hacia esto:

                                         posicionActual=PosicionaMenu(EscTecla,*pposicionActual);

entendiendo que lo que pasaba era el valor de ese puntero, no su dirección. Además, la función TENÍA que devolver el valor del valor del puntero ( no la direccion), asi que al final, me ha dado por hacer :

                                       PosicionaMenu(EscTecla,pposicionActual);

Ahora esta funcion no devuelve ningun valor, pero si lo modifica dentro de ella, y lo que no entiendo muy bien... pero funciona... es a la hora de pasar el parametro
pposicion sin ascerisco. entonces he hecho esto:

Código: C

1. void  PosicionaMenu(int EscTecla,int *pposicionActual){
2.         if ( !pulsador_MenuMas) {
3.                 Delay10KTCYx(10);
4.             *pposicionActual=*pposicionActual+1;
5.         comandXLCD(0x06); // Nos aseguramos incremento de direccion, display fijo
6.                 comandXLCD(0x0C);                       // Encendemos LCD.-
7.                 gotoxyXLCD(1,1);
8.                 putrsXLCD("tecla +");
9.                 Delay10TCYx(10);
10.              
11.         }
12. }

y en main

Código: C

1. int posicionActual;
2. int *pposicionActual;
3.  
4. ///////////////////////////////////
5. ///////////////////////////////////////
6. ///////////////////////////////////
7.  
8. void main(void){
9.  
10.  
11. int  EscTecla=0;
12. pposicionActual=&posicionActual;
13. ADCON1=0xFF;
14. TRISA = 0b10111110;
15. OpenXLCD(FOUR_BIT & LINES_5X7);
16. LATAbits.LATA0=1;
17.  
18. while(1){
19.    
20.     EscTecla=Teclado();
21.     Delay10KTCYx(20);  
22.     PosicionaMenu(EscTecla,pposicionActual);   // por que el parametro pposicionActual NO ES *pposicionActual ?