Ayuda con lcd

[KILLERJC]

No era para mi, era para vos xD.
El primer link tiene varias cosas utiles:

- quitar el Brown Out,  esto te resetea el PIC cuando hay una pequeña caida de tension, en elagunos micros es hasta programable el valor.
- Tener una alimentacion separada o aunque sea tener un diodo + una buena capacidad que mantenga alimentado solo al PIC de esa forma la carga del capacitor solo lo usa el PIC.
 Tengo entendido que con capacitores grandes como de 1uF y baja tension si el PIC se pone a dormir ( en modo bajo consumo ) la carga puede durar mucho tiempo.
Igual esto te va a servir para que veas que si conectas el LCD + PIC sin hacer el circuito de diodo + condensador como sugieren, el LCD podria llegar a terminarte la carga del condensador rapidamente.

igual falta la seccion de sensado y grabado de la eeprom.
Y sobre el grabado en la interrupcion, no encuentro nada, todo en ASM xD

[arielmdq]

Hola KIller ,te cuento que chaly me paso un circuito para hacer lo que veniamos hablando, hoy lo probé y funcionó perfecto  , detecta el flanco de bajada y me da cerca de 3 segundos para grabar en la memoria ,lo estuve probando en varias situaciones del programa y en la unica que no graba como ya lo habias dicho vos, es cuando esta dentro de los delays de 3 segundos.
Ahora lo que pienso es que  la opcion en la que entra en los delays de 3 segundos es cuando se esta visualizando el cuentavueltas en numeros grandes y se pulsa un boton para visualizar el cuenta horas parcial (3seg) y el total (3seg) y luego vuelve al cuentavueltas con numeros grandes.
Yo pienso que va a ser muy poco probable que se quede sin alimentacion justo en este momento teniendo en cuenta que solo se quedará sin alimentacion ante un cambio de batería ,y esto seguramente ocurrira con el motor parado y el cuentavueltas detenido osea
 el programa solo esperando recibir un pulso para comenzar a contar ,tanto vueltas como segundos.Claro que sería buenisimo
que pudiera guardar los datos bajo cualquier circunstancia ,pero bueno ya veremos como ,por lo pronto voy a reducir esos delay
o ver de que otra forma puedo hacer esa parte para seguir visualizando esa funcion pero que no quede atrapado ahí en caso de un
 corte de alimentacion.Cualquier sugerencia soy todo oidos,  bueno ojos  .
                                                                                                                                      Saludos!!!

[KILLERJC]

Excelente 3 segundos es bastante para grabar la EEPROM

Como lo veo quedan 2 soluciones, al menos para mi y tal ves hay otra:

- Grabar en la interrupcion, lo cual exigiria que no se activen las interrupciones, y tal ves es crear la funcion de grabar la EEPROM paso a paso como dice el datasheet.
- Modificar todo el programa para que funcione de otra forma. Mas como una maquina de estados y tomar en cada seccion al comienzo el valor del segundero asi de esa forma poder hacer las animacion que se deban realizar.

La primera es simple, es crear una funcion que cargue los valores a los registros en orden y listo.
La segunda llevaria te llevaria modificar mucho mas el programa ya que tendrias que modificar todo el bucle while del main, para que realize la grabacion alli.

Creo que son las 2 optimas, por supuesto prefiero la primera. Pero eso decidiras vos por cual vas.

[arielmdq]

Hola Killer ,si yo creo que a esta altura ya iría por la primera asi lo terminamos de una vez ,ya me agarro la ansiedad de concluir    ,pero entonces como creamos esta funcion que cargue los valores en los registros en orden y que pueda grabar en la interrupcion ?por que hasta lo que intente de grabar en la interrupcion me marca los warning con y sin delays .No entiendo como debería hacerlo 

[KILLERJC]

Es que justamente no se como hacerlo en CCS, yo use siempre XC8 o directamente ASM. Y lo que hay que hacer es esto:

EEDATA = dato_a_guardar;
EEADR = direccion_del_dato
EECON1 |= 0x04; //WREN = 1
EECON2 = 0x55;  //Proteccion
EECON2 = 0xAA;
EECON1 |= 0x02; // Pedido de escritura de datos
while( EECON1 & ~(0x02) ); // Esto o ver el flag de EEIF, espero que termine, podria ser un bit_test(EECON1,1) !!

Repito eso por cada dato + direccion.
Y finalmente cierro con un :

EECON1 &= ~(0x04); // Pone a 0 el WREN

Eso es en ASM lo que se hace para escribir la EEPROM, ahora como implementar eso en CCS es otro tema. Y pienso que deberia haber una forma de escribir la EEPROM en la interrupcion. Ojo esto unicamente es valido para un programa adentro de la interrupcion, sino deberia desactivar la interrupciones antes.

Codigos encontrados por internet:

Código: C

1. void Write_EEPROM(
2.   UINT8 data,            // byte written to eeprom
3.   UINT8 address)         // EEPROM address to write data
4. {
5.   PIR2bits.EEIF = 0;     // Make sure that the int flag is cleared
6.   EEADRH= 0;             // Load our address
7.   EEADR = address;       // Load our address
8.   EEDATA = data;         // Load our data
9.   EECON1bits.EEPGD = 0;  // Point to data memory
10.   EECON1bits.WREN = 1;   // Enable writes
11.  
12.   // Microchip recommends disabling ints here
13.   global_int(INT_DISABLED);
14.   EECON2 = 0x55;         // Write 0x55
15.   EECON2 = 0xAA;         // Write 0xAA
16.   EECON1bits.WR=1;       // Set WR to begin write
17.   _asm
18.     nop
19.   _endasm
20.   global_int(INT_RESTORE);
21.   while (!PIR2bits.EEIF); // Wait for write to complete
22.  
23.   PIR2bits.EEIF = 0;
24.   EECON1bits.WREN = 0;    // Disable writes
25.   return;
26. }

Código: C

1. int1 eewrite;//flag set in my int_RDA by command to save ram to eeprom
2.  
3. #byte      EECON1 = 0xFA6
4. #define   WR            1
5. #define   WREN        2
6. #define   EEPGD       7
7.  
8. #inline
9. void service_eeprom_wr(void) {
10.     if(!bit_test(EECON1,WR)) {      // was last byte wrote?
11.         if(eewrite) {         // if 1, save next byte
12.         if(eecnt<sizeof(cfg)) {
13.         EEADR = eecnt;
14.         EEDATA = *(&cfg+eecnt);
15.         bit_clear(EECON1,EEPGD);      // Point to DATA memory
16.         bit_set(EECON1,WREN);      // Enable writes
17.         disable_interrupts(global);      // Disable all interrupts
18.         EECON2 = 0x55;      // Write 55h
19.         EECON2 = 0xAA;      // Write AAh
20.         bit_set(EECON1,WR);      // Set WR to begin write
21.         enable_interrupts(global);      // Enable all interrupts
22.                 eecnt++;
23.                         } else { eewrite=0; }
24.                 }
25.         }
26. }

Ojo con los codigos que habilitan la interrupciones y puede que algunas no te sirvan, yo creo que modificando el 1er codigo deberia funcioanr bien y te creas tu funcion quedando algo asi:

ESTE PROGRAMA ES PARA UN PIC16F628A, tu PIC posee otras direcciones (comienzan en 0x10C y algo mas ), 1 bit mas que es el EEPGD que debes ponerlo en 0 al comienzo, la direccion esta separado en 2 registros y no uno solo y lo demas es igual al ejemplo

Código: C

1. #define WR      1
2. #define WREN    2
3.  
4. #byte   EEDATA = 0x9A
5. #byte   EEADR = 0x9B
6. #byte   EECON1 = 0x9C
7. #byte   EECON2 = 0x9D
8.  
9. void Write_EEPROM(
10.   UINT8 data,            // byte written to eeprom
11.   UINT8 address)         // EEPROM address to write data
12. {
13.   EEADR = address;       // Load our address
14.   EEDATA = data;         // Load our data
15.   bit_set(EECON1,WREN);  // Enable writes
16.   EECON2 = 0x55;         // Write 0x55
17.   EECON2 = 0xAA;         // Write 0xAA
18.   bit_set(EECON1,WR);    // Set WR to begin write
19.   _asm
20.     nop
21.   _endasm
22.  
23.   while (bit_test(EECON1,WR); // Wait for write to complete
24.  
25.   bit_clear(EECON1,WREN);    // Disable writes
26.   return;
27. }

Y lo usas con Write_EEPROM(dato_a_guardar,direccion_donde_guardar);

Creo que este seria el correcto para el PIC16F876, no estoy seguro del While(WR) pero bueno.. es lo que logre hacer sin usar CCS

Código: C

1. #word   EEDATA = 0x10C
2. #word   EEADR = 0x10D
3. #word   EEDATH = 0x10E
4. #word   EEADRH = 0x10F
5. #word   EECON1 = 0x18C
6. #word   EECON2 = 0x18D
7.  
8. #bit    WR = EECON1.1
9. #bit    WREN = EECON1.2
10. #bit    EEPGD = EECON1.7
11.  
12.  
13. void Write_EEPROM(
14.   UINT8 data,           // byte written to eeprom
15.   UINT8 address)        // EEPROM address to write data
16. {
17.   EEADR = address;      // Load our address
18.   EEDATA = data;        // Load our data
19.   EEDATH = 0;           // Necesario agregar esto, ya que no sabemos los valores que puedan tener
20.   EEADRH = 0;           // No siempre son cero
21.   EEPGD = 0;            // Lectura de los EEPROM de datos y no programa
22.   WREN = 1;             // Enable writes
23.   EECON2 = 0x55;        // Write 0x55
24.   EECON2 = 0xAA;        // Write 0xAA
25.   WR = 1;               // Set WR to begin write
26.   _asm
27.     nop
28.   _endasm
29.  
30.   while (WR);           // Wait for write to complete , hasta que WR = 0
31.   WREN = 0;             // Disable writes
32.   return;
33. }

[arielmdq]

Hola killerjc, muchas gracias por la explicacion y los ejemplos, no me esta siendo tal facil interpretar esto por ahora veo todo nuevo .Espero no defraudarte ,pero quede asi       voy a necesitar tiempo, cuando tenga algo te cuento.
                                                             Saludos!!!!!

[KILLERJC]

No es nada nuevo, mira el datasheet y ahi te dice todos los pasos para grabar la EEPROM

[Abner_emanuel]

Referente a este tema. Como puedo hacer para imprimir en una pantalla 4x20 en lugar de una 2x16?

[arielmdq]

Hola Abner_emanuel si lo estas haciendo con CCS tenes que incluir la librería  lcd420.c  en vez de  lcd.c :
                                                                                                                                                                    #include <lcd420.c>
Y cuando te referis a donde escribir es igual que en la de 2 x 16 pero cuando marcas la linea le decis si queres escribir en la 1,2,3 o4 asi :
lcd_gotoxy(1,3);
lcd_putc("HOLA");
Aca te va a escribir en la primer posicion de la tercer linea.

[Abner_emanuel]

Gracias por responder, estoy haciendo un semáforo que ya posyie en otro hilo de aquí y que killer me ayudo en algunas dudas que tenía. Pero quiero ponerle en la LCD números grandes y pequeños de un cronómetro que incluye. Gracias por tu atención. Lo pongo por la tarde y me daré a entender mejor.

[arielmdq]

Hola que tal ,quería contar lo que hice con el programa, al final me decidi por cambiarle la logica  basandome en ciclos while con condiciones y dos menu,uno principal y uno de configuracion,logrando de esta manera salir de cualquier parte del programa al momento de la interrupcion producida por la deteccion del flanco de bajada por RB0 y asi recurrir a la grabacion de la memoria antes de perder alimentacion.
Para comprobar la efectiva grabacion luego de hacerla, imprimo en pantalla la palabra apagando, pude probarlo en la placa de pruebas en todas las posibilidades y  funciona ,hasta le agregué controlar el backlight con el programa y desactivarlo al momento de la int ext y tambien funciona con lo cual elimino la posibilidad de tener que conectar el backlight con un regulador aparte .
El circuito utilizado es que me paso chaly29 que con un capacitor de 1000uf ya funciona pero creo que para asegurarme lo subiré a 2200uf.
Otra cosa que me gustaría hacer pero que todavía no logro es que cuando este por mas de un tiempo determinado quieto en una parte del programa ,vuelva al while de las RPM ,antes KILLERJC me recomendo hacerlo por interrupcion por rb0 pero ahora ya lo tengo ocupado a Rb0 asi que esto me queda pendiente .Me gustaría saber que opinan del programa ya que si bien funciona ,como siempre nunca estoy seguro si es la manera correcta  o si de esta manera podré tener problemas a futuro.Desde ya muchas gracias ,los dejo con el programa.Saludos!!!

Código: C

1. #include <16f876a.h>
2. #device adc=10
3. #use delay(clock=4000000)
4. #fuses HS,NOWDT,NOPROTECT,NOLVP,PUT,NODEBUG,BROWNOUT,NOCPD,NOWRT
5. #define LCD_ENABLE_PIN  PIN_B3                                    ////
6. #define LCD_RS_PIN      PIN_B1                                    ////
7. #define LCD_RW_PIN      PIN_B2                                    ////
8. #define LCD_DATA4       PIN_B4                                    ////
9. #define LCD_DATA5       PIN_B5                                    ////
10. #define LCD_DATA6       PIN_B6                                    ////
11. #define LCD_DATA7       PIN_B7
12. #include <lcd.c>
13. #include <NumGran.C>
14. #include <internal_eeprom.c>
15. #use fast_io(B)
16. #use fast_io(c)
17. #use fast_io(a)
18. //****variables del cuneta vueltas***//
19. int16 contador=0,RPM,i;
20. float ajuste=10,e;      
21. //****variables del cuneta horas***//
22. int8 Segundos=0,SegundosParcial=0,Minuto=0,MinutoParcial=0;
23. int menu=0,x=0;
24. int16 b=0,service=0, Hora=0,cont=0, HoraParcial=0,mantenimiento=1;
25. short grabar=0;
26. unsigned int16 duty = 0;
27. //*********Funciones**************************
28.  
29. int menus(void)
30. {
31.  return (menu+'1');
32. }
33.  
34. #int_ext
35. void corte()
36.  {  duty = 0;
37.     x=0;
38.     grabar=1;        
39.  }
40.  
41. #int_CCP1
42. void  CCP1_isr(void)
43. {
44.  cont++;
45.   if (cont==2)
46.   {
47.    contador=get_timer0();
48.    set_timer0(0);
49.    
50.    cont=0;
51.  //  if (rpm>600)
52.  //  {
53.     Segundos++;
54.     SegundosParcial++;
55.    
56. //  }
57. //*********Cuenta Horas Total**********************************/        
58.       if(Segundos == 60)
59.       {
60.           Minuto++;
61.           Segundos=0;
62.              
63.       if(Minuto == 60)
64.        {
65.           Hora++;
66.           Minuto=0;
67.        }
68.       }
69. /**********Cuenta Horas Parcial*********************************/
70.       if(SegundosParcial == 60)
71.       {          
72.           MinutoParcial++;
73.           SegundosParcial=0;
74.              
75.       if(MinutoParcial == 60)
76.        {
77.          
78.           HoraParcial++;
79.           MinutoParcial=0;
80.        }
81.     }
82.    
83.   }    
84. }
85. //***************************************************
86. void main()
87. {
88.     set_tris_a(0b00010000);
89.     output_a(0b00000000);
90.     set_tris_c(0b01111100);
91.     output_c(0b00000000);
92.     set_tris_b(0b00000001);
93.     output_b(0b00000000);
94.    
95. //********************pwm2************************************      
96.    setup_ccp2(CCP_PWM);
97.    setup_timer_2(T2_DIV_BY_16,255, 1);
98.    set_pwm2_duty(duty);  
99.    setup_adc_ports(NO_ANALOGS);
100. //**************** INT CCP1 ***********************************
101.     setup_timer_0(rtcc_ext_h_to_l | rtcc_div_2);
102.     setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
103.     setup_ccp1(CCP_COMPARE_RESET_TIMER);
104.     CCP_1 = 62500;
105.     set_timer1(0);
106.     set_timer0(0);
107. //***************INT EXT**************************************    
108.     enable_interrupts(int_ext);
109.     ext_int_edge(h_to_l);
110.     enable_interrupts(INT_CCP1);
111.     enable_interrupts(GLOBAL);
112.  
113.  //*************Lectura de eeprom ****************************
114.    Hora=read_int16_eeprom(100);
115.    delay_ms(15);
116.    HoraParcial=read_int16_eeprom(110);
117.    delay_ms(15);  
118.    Minuto=read_eeprom(120);
119.    delay_ms(15);
120.    MinutoParcial=read_eeprom(130);
121.    delay_ms(15);
122.    e=read_float_eeprom(140);
123.    delay_ms(15);
124.    service=read_int16_eeprom(150);
125.    delay_ms(15);
126.    mantenimiento=read_int16_eeprom(160);
127.    delay_ms(15);
128. //*************************************************************
129.     lcd_init();
130.     NumGran_Init();      
131.     lcd_gotoxy(1,1);          
132.     lcd_putc("      RPM       \n  CUENTA HORAS ");          
133.     delay_ms(2000);              
134.     lcd_putc("\f");
135.  
136.  while(x==0)
137.     {  
138.       if(grabar==1)
139.        {
140.           write_int16_eeprom(100, Hora);
141.           write_int16_eeprom(110, HoraParcial);        
142.           write_eeprom(120, Minuto);
143.           write_eeprom(130, MinutoParcial);
144.           grabar=0;
145.           lcd_putc("\f");          
146.           lcd_putc("    APAGANDO     ");          
147.           delay_ms(500);
148.        }
149.           lcd_gotoxy(1,1);          
150.           printf(lcd_putc," MENU PRINCIPAL   ");          
151.  
152.        if (input(pin_c2))          //Paso al siguiente menu
153.          { delay_ms(100);
154.            while(input(pin_c2));
155.             x+=1;                          
156.           }
157.        if(input(PIN_c4)==1)       //Regula el backlight del lcd
158.         { delay_ms(100);
159.           duty +=15;
160.          
161.           if (duty >1023){duty = 1023;}  
162.         }
163.        if(input(PIN_c5)==1)       //Regula el backlight del lcd
164.         { delay_ms(100);
165.           duty -=15;
166.          
167.           if (duty > 1023){duty = 0;}  
168.         }
169.          lcd_gotoxy(1,2);
170.          printf(lcd_putc," BACK LIGHT:%04lu  ",duty);        
171.          set_pwm2_duty(duty);
172.          menu=0;                // vuelve a cero el menu
173.          
174.  while (x==1)                   //Lectura de RPM
175.   {
176.        if (input(pin_c2))      //Paso al siguiente menu
177.          { delay_ms(100);
178.            while(input(pin_c2));
179.             x+=1;                          
180.           }
181.          mantenimiento=read_int16_eeprom(160);
182.          delay_ms(15);        
183.          service=read_int16_eeprom(150);
184.          delay_ms(15);
185.          e=read_float_eeprom(140);
186.          delay_ms(15);
187.          
188.          RPM= contador*e;        
189.          i =RPM;
190.          
191.          lcd_send_byte(0,1);
192.          delay_us(2);
193.          NumGran(i);
194.          printf(lcd_putc,"RPM");
195.          delay_ms(80);    
196.          
197.          i = RPM;
198.          delay_ms(300);                  
199.          printf(lcd_putc," %04lu",i);    
200.            
201.      if ( Minuto>=mantenimiento&&(input(pin_c2)==0))//ATENCION cambiar Minuto por horas
202.       {    
203.          
204.         lcd_gotoxy(13,1);
205.         lcd_putc("Mant ");//
206.         delay_ms(500);
207.      
208.       }
209.  //********************pwm2**************************************
210.  
211.     }
212.    
213.  while (x==2)                    //cuenta horas parcial y total
214.      {
215.    
216.        if (input(pin_c2))
217.          { delay_ms(50);
218.            while(input(pin_c2));
219.             x+=1;                          
220.          }  
221.  
222.          lcd_gotoxy(1,1);
223.          printf(lcd_putc,"Par  %05lu:%02u:%02u",HoraParcial,MinutoParcial,SegundosParcial);
224.          
225.          lcd_gotoxy(1,2);
226.          printf(lcd_putc,"Tot  %05lu:%02u:%02u",Hora,Minuto,Segundos);
227.            
228.       }  
229.                                  
230.    while (x==3)                        //Aviso de proximo service
231.     {
232.        if (input(pin_c2))             //Paso al siguiente menu
233.          { delay_ms(50);
234.            while(input(pin_c2));
235.             x+=1;                          
236.           }
237.            service=read_int16_eeprom(150);
238.            delay_ms(15);
239.            lcd_gotoxy(1,1);
240.            printf(lcd_putc,"Proximo Service \n   %4lu Horas     ",service);          
241.          
242.     }
243.        
244.  /***********************ENTRA AL  MENU*************************************/
245.  
246.    while (x==4)
247.     {
248.        if (input(pin_c2))         //Paso al siguiente menu
249.          { delay_ms(50);
250.            while(input(pin_c2));
251.             x=0;                          
252.           }    
253.         menus();                //Funcion de menus
254.              
255.         if (input(pin_c3))      //desplaza dentro de la configuracion
256.        {   delay_ms(50);
257.        while(input(pin_c3));
258.         {
259.            menu++;  
260.        if (menu>6)
261.            menu=0;            
262.         }          
263.        }
264.      
265.    switch (menu+1)
266.    {
267.      case  1:                    //Aviso de entrada en configuracion
268.                  
269.               lcd_gotoxy(1,1);
270.               printf(lcd_putc," CONFIGURACION    \n                   ");
271.              
272.               break;
273.                  
274.      case  2 :                  //Service
275.  
276.               lcd_gotoxy(1,1);
277.               printf(lcd_putc,"Programe Service");
278.  
279.               if (input(pin_c4)==1)    
280.              {    delay_ms(200);       // antirebote
281.                
282.                     b+=1;        
283.              }
284.              if (input(pin_c5)==1)  // Boton que decrementa
285.              { delay_ms(200);
286.              
287.                     b-=1;
288.              }
289.              
290.              lcd_gotoxy(1,2);
291.              printf(lcd_putc,"   Horas  %4lu    ",b);
292.              
293.              if (input(pin_c6)==1)
294.              { delay_ms(50);
295.               while(input(pin_c6));            
296.                write_int16_eeprom(150, b);  // escribe en la memoria
297.                delay_ms(25);
298.                service=read_int16_eeprom(150);
299.                delay_ms(15);
300.                mantenimiento=Minuto+service;//ATENCION cambiar Minuto por hora
301.                write_int16_eeprom(160,mantenimiento);  // escribe en la memoria
302.                delay_ms(15);              
303.                mantenimiento=read_int16_eeprom(160);
304.                delay_ms(15);
305.                lcd_gotoxy(1,2);
306.                printf(lcd_putc,"    Memorizado     ");
307.                delay_ms(1000);
308.              }
309.               break;
310.              
311.      case  3 :                               //CALIBRA RPM
312.               e=read_float_eeprom(140);
313.               delay_ms(15);
314.               RPM= contador*e;
315.               lcd_gotoxy(1,1);
316.               printf(lcd_putc,"Actual RPM %lu       ",RPM);
317.               if (input(pin_c4)==1)
318.              {  
319.                    delay_ms(200);                    
320.                    ajuste+=0.02;          // Incremento
321.              }
322.              if (input(pin_c5)==1)
323.              {  
324.                  delay_ms(200);
325.                  ajuste-=0.02;        //Decremento  
326.              }              
327.              if (input(pin_c6)==1)
328.              { delay_ms(50);
329.               while(input(pin_c6));            
330.                write_float_eeprom(140, ajuste);  
331.                delay_ms(15);  
332.              }              
333.               RPM= contador*ajuste;
334.               lcd_gotoxy(1,2);
335.               printf(lcd_putc,"Ajuste RPM %lu       ",RPM);        
336.               break;
337.                
338.      case  4 :                                
339.               lcd_gotoxy(1,1);
340.               printf(lcd_putc,"   RESET TOTAL    ");
341.               lcd_gotoxy(1,2);
342.               printf(lcd_putc,"   %05lu:%02u:%02u  ",Hora,Minuto,Segundos);
343.               if (input(pin_c6)==1) // Reset de cuenta horas parcial
344.                {  delay_ms(300);
345.                   Hora=00000;
346.                   write_int16_eeprom(100, Hora);
347.                   delay_ms(15);
348.                   Minuto=00;
349.                   write_eeprom(120, Minuto);
350.                   delay_ms(15);
351.               }
352.               break;  
353.  
354.              
355.      case  5 :
356.               lcd_gotoxy(1,1);
357.               printf(lcd_putc,"  RESET PARCIAL    ");
358.               lcd_gotoxy(1,2);
359.               printf(lcd_putc,"   %05lu:%02u:%02u  ",HoraParcial,MinutoParcial,Segundos);
360.               if (input(pin_c6)==1) // Reset de cuenta horasparcial
361.                {  delay_ms(300);
362.                   HoraParcial=00000;
363.                   write_int16_eeprom(110, HoraParcial);
364.                   delay_ms(15);              
365.                   MinutoParcial=00;
366.                   write_eeprom(130, MinutoParcial);
367.                   delay_ms(15);
368.                }
369.               break;              
370.       case  6 :
371.                menu=0;
372.                break;
373.    }        
374.  }        
375.     }
376.  
377. }

[Abner_emanuel]

Que tal arielmdq te adjunto un code el cual había comentado que requería los números grandes en lcd, cosa que por el momento descarte. Aun que aun asi lo comparto y espero te sirvaen algo, ya que este lleva el grabar datos en la eeprom y menú.

Código: CSS

1. #include <18F4550.h>
2.          #priority int_ext
3.          #fuses PLL1,CPUDIV1,USBDIV,XTPLL,NOFCMEN,NOIESO,PUT,NOBROWNOUT,VREGEN,NOWDT,WDT32768,NOPBADEN,MCLR,NOSTVREN,NOLVP,NODEBUG,PROTECT,NOSTVREN,NOCPB,NOWRT
4.          #use delay(clock=48000000,RESTART_WDT)
5.          #byte porta = 0xF80 #byte portb = 0xF81 #byte portc = 0xf82 #byte portd = 0xf83 #byte porte = 0xf84  
6.        
7.          #byte pb      = 0xF81
8.          #bit t_ok     = pb.0
9.          #bit t_mas    = pb.1
10.          #bit t_mns    = pb.2
11.          #byte intcon  = 0xFF2
12.          #byte intcon3 = 0xFF0
13.          #bit  intf    = intcon.1
14.          #bit  intf1   = intcon3.0
15.          #bit  intf2   = intcon3.1        
16.          #use fast_io(b)
17.          #define led_verde    output_e(4);
18.          #define led_naranja  output_e(2);
19.          #define led_rojo     output_e(1);
20.          #define led_off      output_e(0);
21.          #include <lcd4x20.c>
22.          #include <menu.h>  
23.          
24.          static unsigned int8 seg_tmr0=0, min_tmr0=0, seg_0=0, min_0=0, seg_1=0, min_1=0, seg_2=0, min_2=0, bandera=0;
25.          void arranque(void);                                        
26.          void suma_tiempo_eeprom(void);
27.          
28.          #int_timer0                                                    // Interrupcion para 1S
29.          void timer0(void)
30.          { seg_tmr0++; if(seg_tmr0>59){seg_tmr0=0; min_tmr0++;} if(min_tmr0>59){min_tmr0=0;} set_timer0(18652);}
31.          
32.          #INT_EXT1
33.          void pausa()
34.          { disable_interrupts(INT_TIMER0); }
35.          
36.          #INT_EXT2
37.          void continua()
38.          { enable_interrupts(INT_TIMER0);  }
39.          
40.          void main(void)
41.          {        
42.          port_b_pullups(true);
43.          setup_adc_ports(NO_ANALOGS);
44.          lcd_init();
45.          
46.          intf=0; intf1=0; intf2=0;        
47.          setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);                
48.          set_timer0(18661);
49.          
50.          enable_interrupts(INT_EXT);
51.          enable_interrupts(INT_EXT1);
52.          enable_interrupts(INT_EXT2);
53.          disable_interrupts(INT_TIMER0);
54.          enable_interrupts(GLOBAL);
55.          
56.          seg_tmr0=0,min_tmr0=0,seg_0=0,min_0=0,seg_1=0,min_1=0,seg_2=0,min_2=0,bandera=0;
57.          eeprom_segundos_0=0,eeprom_minutos_0=0,eeprom_segundos_1=0,eeprom_minutos_1=0,eeprom_segundos_2=0,eeprom_minutos_2=0;    
58.          
59.          eeprom_minutos_1=read_eeprom(INT_EEPROMA); eeprom_segundos_1=read_eeprom(INT_EEPROMB); eeprom_minutos_2=read_eeprom(INT_EEPROMC);
60.          eeprom_segundos_2=read_eeprom(INT_EEPROMD); eeprom_minutos_0=read_eeprom(INT_EEPROME); eeprom_segundos_0=read_eeprom(INT_EEPROMF);
61.          led_off
62.          
63.          while(true)
64.          {
65.          lcd_gotoxy(1,1); printf(lcd_putc,"TIME TOTAL = %02u:%02u"minutos_total,segundos_total);
66.          lcd_gotoxy(1,2); printf(lcd_putc,"TIME1 %02u:%02u  %02u:%02u",min_0,seg_0,eeprom_minutos_0,eeprom_segundos_0);
67.          lcd_gotoxy(1,3); printf(lcd_putc,"TIME2 %02u:%02u  %02u:%02u",min_1,seg_1,eeprom_minutos_1,eeprom_segundos_1);
68.          lcd_gotoxy(1,4); printf(lcd_putc,"TIME3 %02u:%02u  %02u:%02u",min_2,seg_2,eeprom_minutos_2,eeprom_segundos_2);        
69.          arranque(); cgram_reloj_1(); suma_tiempo_eeprom();
70.          
71.          }
72.          }
73.                  
74.          void arranque(void)        
75.          {
76.          if(!input(pin_b3)) { delay_ms(200); bandera=1; enable_interrupts(INT_TIMER0);}  
77.          if (bandera==1)   { seg_0=seg_tmr0; min_0=min_tmr0; led_verde   if(eeprom_segundos_0==seg_0 && eeprom_minutos_0==min_0){seg_tmr0=0; min_tmr0=0; bandera=2;}}
78.          if (bandera==2)   { seg_1=seg_tmr0; min_1=min_tmr0; led_naranja if(eeprom_segundos_1==seg_1 && eeprom_minutos_1==min_1){seg_tmr0=0; min_tmr0=0; bandera=3;}}        
79.          if (bandera==3)   { seg_2=seg_tmr0; min_2=min_tmr0; led_rojo    if(eeprom_segundos_2==seg_2 && eeprom_minutos_2==min_2){seg_tmr0=0; min_tmr0=0; bandera=4; led_off}}  
80.          if (seg_0>=2 && !input(pin_b3)) { while(seg_0>=2 && !input(pin_b3)); disable_interrupts(GLOBAL);}
81.          }
82.          
83.          void suma_tiempo_eeprom(void)
84.          {
85.          segundos_total = eeprom_segundos_0 + eeprom_segundos_1 + eeprom_segundos_2;
86.          minutos_total = eeprom_minutos_0 + eeprom_minutos_1 + eeprom_minutos_2;
87.          aux = segundos_total/60;                                       // Solo divido una ves ya que es lo mas consumidor
88.          minutos_total += aux;
89.          segundos_total -= aux*60;
90.          }

y el menú.h es elsiguiente:

Código: CSS

1. unsigned int8 INT_EEPROMA = 0;
2.          unsigned int8 INT_EEPROMB = 1;
3.          unsigned int8 INT_EEPROMC = 2;
4.          unsigned int8 INT_EEPROMD = 3;
5.          unsigned int8 INT_EEPROME = 4;
6.          unsigned int8 INT_EEPROMF = 5;
7.          
8.          void menu_cronometro_1(void);    
9.          void menu_cronometro_2(void);
10.          void menu_cronometro_3(void);
11.          void cgram_reloj(void);
12.          void cgram_reloj_1(void);
13.          void cgram_flecha(void);
14.          
15.          static unsigned int8 testado,i,k;
16.          int segundos_total,minutos_total,aux;
17.          static unsigned int8 eeprom_segundos_0=0, eeprom_minutos_0=0, eeprom_segundos_1=0, eeprom_minutos_1=0, eeprom_segundos_2=0, eeprom_minutos_2=0;  
18.          int const  relojChar[8]={0,14,19,21,17,14,31,0};
19.          int const  flechaChar[8]={0,4,8,31,8,4,0,0};
20.          
21.          #INT_EXT
22.          void menu()
23.          {
24.          disable_interrupts(GLOBAL);
25.          disable_interrupts(INT_EXT);
26.          disable_interrupts(INT_EXT1);
27.          disable_interrupts(INT_EXT2);
28.          delay_ms(300);
29.          testado=0;
30.          lcd_putc("\f");
31.          lcd_gotoxy(2,1); lcd_putc("AJUSTE OPCION: [ ]");
32.          lcd_gotoxy(1,2); lcd_putc("[1] CRONOMETRO 1   ");
33.          lcd_gotoxy(1,3); lcd_putc("[2] CRONOMETRO 2   ");
34.          lcd_gotoxy(1,4); lcd_putc("[3] CRONOMETRO 3   ");
35.          
36.          for(i=0;i!=255;i++)
37.          {
38.          delay_ms(20);
39.          lcd_gotoxy(18,1);
40.          printf(lcd_putc,"%u",testado);
41.          if (!t_ok){delay_ms(300); break;}
42.          else if (!t_mas){i=0; delay_ms(300); testado++; if(testado>3){testado=0;};}
43.          else if (!t_mns){i=0; delay_ms(300); testado--; if(testado==255){testado=3;};}        
44.          if(testado==0){ lcd_gotoxy(18,2); printf(lcd_putc,"  "); lcd_gotoxy(18,3); printf(lcd_putc,"  "); lcd_gotoxy(18,4); printf(lcd_putc,"  "); }
45.          if(testado==1){ cgram_flecha(); lcd_gotoxy(18,2); lcd_send_byte(1,0); lcd_gotoxy(18,3); printf(lcd_putc,"  "); lcd_gotoxy(18,4); printf(lcd_putc,"  "); }
46.          if(testado==2){ cgram_flecha(); lcd_gotoxy(18,3); lcd_send_byte(1,0); lcd_gotoxy(18,2); printf(lcd_putc,"  "); lcd_gotoxy(18,4); printf(lcd_putc,"  "); }
47.          if(testado==3){ cgram_flecha(); lcd_gotoxy(18,4); lcd_send_byte(1,0); lcd_gotoxy(18,2); printf(lcd_putc,"  "); lcd_gotoxy(18,3); printf(lcd_putc,"  "); }        
48.          };
49.          if(testado==0)
50.          {
51.          intf=0; intf1=0; intf2=0;
52.          enable_interrupts(GLOBAL);
53.          enable_interrupts(INT_EXT);
54.          enable_interrupts(INT_EXT1);
55.          enable_interrupts(INT_EXT2);
56.          lcd_putc("\f");
57.          break;
58.          }
59.          else if(testado==1){menu_cronometro_1(); lcd_putc("\f");}
60.          else if(testado==2){menu_cronometro_2(); lcd_putc("\f");}
61.          else if(testado==3){menu_cronometro_3(); lcd_putc("\f");}
62.          }
63.          
64. ////////////////////////////////////////////////////////////////////////////////
65. //    Submenu Ajuste RTC
66. //
67. ///////////////////////////////////////////////////////////////////////////////
68.          
69.          void menu_cronometro_1(void)
70.          {
71.          lcd_putc("\f");        
72.          lcd_gotoxy(5,1); lcd_putc("CRONOMETRO 1");
73.          lcd_gotoxy(2,3); printf(lcd_putc,"TIEMPO 1: %02u:%02u",eeprom_minutos_0,eeprom_segundos_0);
74.          cgram_reloj();
75.        
76.          for(i=0;i!=255;i++)
77.          {
78.          delay_ms(20);
79.          lcd_gotoxy(12,3); printf(lcd_putc,"%02u",eeprom_minutos_0); lcd_gotoxy(12,4); printf(lcd_putc,"--");
80.          if(!t_ok){delay_ms(300); break;}
81.          else if(!t_mas){i=0; delay_ms(300); eeprom_minutos_0++; if(eeprom_minutos_0>59)  {eeprom_minutos_0=0;}; }
82.          else if(!t_mns){i=0; delay_ms(300); eeprom_minutos_0--; if(eeprom_minutos_0==255){eeprom_minutos_0=59;};}        
83.          }; write_eeprom(INT_EEPROMA,eeprom_minutos_0);
84.        
85.          for(i=0;i!=255;i++)
86.          {
87.          delay_ms(20);
88.          lcd_gotoxy(15,3); printf(lcd_putc,"%02u",eeprom_segundos_0); lcd_gotoxy(12,4); printf(lcd_putc,"   --");
89.          if(!t_ok){delay_ms(300); break;}
90.          else if(!t_mas){i=0; delay_ms(300); eeprom_segundos_0++; if(eeprom_segundos_0>59)  {eeprom_segundos_0=0;}; }
91.          else if(!t_mns){i=0; delay_ms(300); eeprom_segundos_0--; if(eeprom_segundos_0==255){eeprom_segundos_0=59;};}        
92.          }; write_eeprom(INT_EEPROMB,eeprom_segundos_0);
93.          
94.          intf=0; intf1=0; intf2=0;
95.          enable_interrupts(GLOBAL);
96.          enable_interrupts(INT_EXT);
97.          enable_interrupts(INT_EXT1);
98.          enable_interrupts(INT_EXT2);
99.          }
100.          
101. ////////////////////////////////////////////////////////////////////////////////
102.          
103.          void menu_cronometro_2(void)
104.          {
105.          lcd_putc("\f");        
106.          lcd_gotoxy(5,1); lcd_putc("CRONOMETRO 2");
107.          lcd_gotoxy(2,3); printf(lcd_putc,"TIEMPO 2: %02u:%02u",eeprom_minutos_1,eeprom_segundos_1);
108.          cgram_reloj();
109.          
110.          for(i=0;i!=255;i++)
111.          {
112.          delay_ms(20);
113.          lcd_gotoxy(12,3); printf(lcd_putc,"%02u",eeprom_minutos_1); lcd_gotoxy(12,4); printf(lcd_putc,"--");
114.          if(!t_ok){delay_ms(300); break;}
115.          else if(!t_mas){i=0; delay_ms(300); eeprom_minutos_1++; if(eeprom_minutos_1>59)  {eeprom_minutos_1=0;}; }
116.          else if(!t_mns){i=0; delay_ms(300); eeprom_minutos_1--; if(eeprom_minutos_1==255){eeprom_minutos_1=59;};}        
117.          }; write_eeprom(INT_EEPROMC,eeprom_minutos_1);
118.          
119.          for(i=0;i!=255;i++)
120.          {
121.          delay_ms(20);
122.          lcd_gotoxy(15,3); printf(lcd_putc,"%02u",eeprom_segundos_1); lcd_gotoxy(12,4); printf(lcd_putc,"   --");
123.          if(!t_ok){delay_ms(300); break;}
124.          else if(!t_mas){i=0; delay_ms(300); eeprom_segundos_1++; if(eeprom_segundos_1>59)  {eeprom_segundos_1=0;}; }
125.          else if(!t_mns){i=0; delay_ms(300); eeprom_segundos_1--; if(eeprom_segundos_1==255){eeprom_segundos_1=59;};}        
126.          }; write_eeprom(INT_EEPROMD,eeprom_segundos_1);
127.          
128.          intf=0; intf1=0; intf2=0;
129.          enable_interrupts(GLOBAL);
130.          enable_interrupts(INT_EXT);
131.          enable_interrupts(INT_EXT1);
132.          enable_interrupts(INT_EXT2);
133.          }
134.          
135. ////////////////////////////////////////////////////////////////////////////////
136.  
137.          void menu_cronometro_3(void)
138.          {
139.          lcd_putc("\f");        
140.          lcd_gotoxy(5,1); lcd_putc("CRONOMETRO 3");
141.          lcd_gotoxy(2,3); printf(lcd_putc,"TIEMPO 3: %02u:%02u",eeprom_minutos_2,eeprom_segundos_2);
142.          cgram_reloj();
143.          
144.          for(i=0;i!=255;i++)
145.          {
146.          delay_ms(20);
147.          lcd_gotoxy(12,3); printf(lcd_putc,"%02u",eeprom_minutos_2); lcd_gotoxy(12,4); printf(lcd_putc,"--");
148.          if(!t_ok){delay_ms(300); break;}
149.          else if(!t_mas){i=0; delay_ms(300); eeprom_minutos_2++; if(eeprom_minutos_2>59)  {eeprom_minutos_2=0;}; }
150.          else if(!t_mns){i=0; delay_ms(300); eeprom_minutos_2--; if(eeprom_minutos_2==255){eeprom_minutos_2=59;};}        
151.          }; write_eeprom(INT_EEPROME,eeprom_minutos_2);
152.          
153.          for(i=0;i!=255;i++)
154.          {
155.          delay_ms(20);
156.          lcd_gotoxy(15,3); printf(lcd_putc,"%02u",eeprom_segundos_2); lcd_gotoxy(12,4); printf(lcd_putc,"   --");
157.          if(!t_ok){delay_ms(300); break;}
158.          else if(!t_mas){i=0; delay_ms(300); eeprom_segundos_2++; if(eeprom_segundos_2>59)  {eeprom_segundos_2=0;}; }
159.          else if(!t_mns){i=0; delay_ms(300); eeprom_segundos_2--; if(eeprom_segundos_2==255){eeprom_segundos_2=59;};}            
160.          }; write_eeprom(INT_EEPROMF,eeprom_segundos_2);
161.          
162.          intf=0; intf1=0; intf2=0;
163.          enable_interrupts(GLOBAL);
164.          enable_interrupts(INT_EXT);
165.          enable_interrupts(INT_EXT1);
166.          enable_interrupts(INT_EXT2);
167.          break;
168.          }
169.          
170.          void cgram_reloj(void)
171.          {                  
172.          lcd_send_byte(0,0x40);                                                      
173.          for (k=0;k<8;k++) {lcd_send_byte(1,relojChar[k]);} lcd_gotoxy(19,3); lcd_send_byte(1,0);          
174.          }
175.                
176.          void cgram_reloj_1(void)
177.          {
178.          lcd_send_byte(0,0x48);                                                      
179.          for (k=0;k<8;k++) {lcd_send_byte(1,relojChar[k]);} lcd_gotoxy(20,2); lcd_send_byte(1,1); lcd_gotoxy(20,3); lcd_send_byte(1,1); lcd_gotoxy(20,4); lcd_send_byte(1,1);  
180.          }
181.          
182.          void cgram_flecha(void)
183.          {                  
184.          lcd_send_byte(0,0x40);                                                      
185.          for (k=0;k<8;k++) {lcd_send_byte(1,flechaChar[k]);} lcd_gotoxy(18,2); lcd_send_byte(1,0);          
186.          }
187.            
188.          
189. ////////////////////////////////////////////////////////////////////////////////

 

[arielmdq]

Muchas gracias emanuel lo voy a chequear

[Abner_emanuel]

Parece que te envíe una versión anterior, en esta que envío esta un poco mas clara y con algunos cambios mas eficientes.

Yo lo realice un semáforo de tiempo configurable que me pidió un amigo. El lo utilizaría para dar clases de oratoria en la que los alumnos tenían cierto tiempo para exponer.
El tiempo es configurable debido a que como van aumentando el nivel van dando mas tiempo de exposición. Bueno espero te sirva de algo y gracias a killerjc por su ayuda.

[KILLERJC]

arielmdq, a no ser que exista un while grande que encierre a todos los while , nunca va a entrar de nuevo al while(x==0), estas cada vez mas cerca de la solucion que decia antes.

Código: C

1. while(1)
2. {
3.  
4.    switch(x) {
5.         case 0:
6.                 Codigo_while0();  //Aca el codigo de lo que tenes dentro del while x==0
7.                 break;
8.         case 1:
9.                 Codigo_while1();  //Aca el codigo de lo que tenes dentro del while x==1
10.                 break;
11.         case 2:
12.                 Codigo_while2();  //Aca el codigo de lo que tenes dentro del while x==2
13.                 break;
14.         case 3:
15.                 Codigo_while3();  //Aca el codigo de lo que tenes dentro del while x==3
16.                 break;
17.         case 4:
18.                 Codigo_while4();  //Aca el codigo de lo que tenes dentro del while x==4
19.                 break;
20.         default:
21.                 x=1;    //x no termino con un valor correcto, hubo un problema, entonces lo pongo en el valor inicial que corresponda
22.                 break;
23.      }
24. }

A tu codigo lo podes dividir en funciones, asi que no te quedan 2 SUPER SWITCH en el codigo. Y el main te queda limpio y facil de entender.
Sino tu codigo estaria peor que los codigos anteriores. Pensa que nunca deberias tener muchos while o do..while.