Autor Tema: Ayuda con lcd (Leído 23569 veces)

arielmdq · « **Respuesta #60 en:** 28 de Octubre de 2015, 09:09:56 »

Hola killerjc, efectivamente el while (x==0) es el while que encierra todo ,de esta manera tambien puedo hacer todo con pulsadores ,ya no necesito mas el interruptor que antes tenía para pasar del menu principal a la configuracion .Ahora pulsando pin_C2 me desplazo por el menu principal siempre de manera ascendente cuando llega al while(x==4) vuelve a empezar por el while (x==0).
Cuando llega al while(x==4) muestro la palabra configuracion ,que para no entrar accidentalmente en la configuracion cambio de pulsador,ahora con el pin_C3 me desplazo dentro de la configuracion, con pin_C4 y pin_ C5 incremento o decremento las variables y con pin_C6 grabo en memoria.Cuando me encuentro dentro de configuracion pulsando pin_C2 vuelvo al menu principal .
Esta es la manera en que lo pensé, lo que no quiere decir ni que sea correcta ni que sea prolija

.
Pero bueno la opcion que propones ahora es claramente mas clara valga la redundancia

bien voy a probar con dividirlo en funciones como me decis.
Entonces sería un while y un switch y cada case sea una funcion ?.
Tengo que armar todas la funciones antes del void main () ?
Y todo el menu de configuracion tambien quedaría dentro de un case ?
Te cuento, no me enrrosque mucho en implementar lo del codigo en asm que me explicaste la otra vez,por que seguí haciendo pruebas y ya no era un problema lo de grabar en la memoria, con lo del circuito de chaly tengo tiempo suficiente para hacerlo hasta imprimo una palabra despues de grabar y antes que se termine la alimentacion y no me ha fallado .Pero lo que si me interesa es lo optimizar el codigo y aprender a hacerlo como corresponde.
Como siempre te agradezco mucho la ayuda .
Saludos !!!

KILLERJC · « **Respuesta #61 en:** 28 de Octubre de 2015, 09:22:11 »

Esta bien. pense que no habia un while que encerrara todo, pero tenes que asegurarte que NO salga de ese while, es decir siempre exista un loop infinito.
Por lo tanto el while(x==0) deberias ser mas un while(1) , asi nunca, bajo ninguna cirscuntancia es posible salir de ese while

arielmdq · « **Respuesta #62 en:** 28 de Octubre de 2015, 09:25:31 »

Aaa ok te entiendo

arielmdq · « **Respuesta #63 en:** 31 de Octubre de 2015, 08:21:52 »

Hola Killerjc ,volvi a cambiar el programa mas o menos como me recomendaste y queria subirlo para ver que opinas .Ahora hice un par funciones ,un bucle infinito y dentro de él 2, while (chiste : no puedo salir de los while

) en uno se encuentra el switch y las condiciones para desplazarme sobre él .Lo hice para poder moverme de la misma forma que el programa anterior ,con un menu principal y uno de configuracion, cuando llego al case 5 que es el ingreso a la configuracion ,para poder entrar tengo que pulsar otro boton sino vuelvo al menu principal.Lo bueno ahora es que pude eliminar otro pulsador ahora solo tengo 4,(antes5).
Y el otro while es el que entra con la interrupcion cuando detecta el flanco de bajada por Rb0 desactivo la backlight y coloco en 1 la bandera (grabar) y de esta forma me aseguro que se graben los datos en memoria ,cuando termina pongo grabar otra vez en 0.
Preguntas:
Tengo partes dentro del switch (case 6,7,8,9 ) donde configuro parametros ,aca tambien tendría que hacer funciones fuera del main y luego llamarlas en los case ? tiene algun sentido ?
Tengo dudas en las partes en las que leo la memoria ya sea para luego imprimir en pantalla o para hacer cuentas con ese dato es necesario siempre aclarar :service=read_int16_eeprom(150);antes de usarlo( en este caso service)o con que este declarado dentro del void main() ya esta y no tengo que volver a llamarlo?
Aca esta el codigo:

Código: C

#include <16f876a.h>
#device adc=10
#use delay(clock=4000000)
#fuses HS,NOWDT,NOPROTECT,NOLVP,PUT,NODEBUG,BROWNOUT,NOCPD,NOWRT
#define LCD_ENABLE_PIN  PIN_B3                                    ////
#define LCD_RS_PIN      PIN_B1                                    ////
#define LCD_RW_PIN      PIN_B2                                    ////
#define LCD_DATA4       PIN_B4                                    ////
#define LCD_DATA5       PIN_B5                                    ////
#define LCD_DATA6       PIN_B6                                    ////
#define LCD_DATA7       PIN_B7 
#include <lcd.c>
#include <NumGran.C>
#include <internal_eeprom.c>
#use fast_io(B)
#use fast_io(c)
#use fast_io(a)
 
//****variables del cuneta vueltas***//
int16 contador=0,RPM,duty=0;
float ajuste=10,e;       
//****variables del cuneta horas***//
int8 Segundos=0,SegundosParcial=0,Minuto=0,MinutoParcial=0;
int menu=0;
int16 b=0,service=0, Hora=0,cont=0, HoraParcial=0,mantenimiento=0;
short grabar=0,flag=0;
 
//*********Funciones**************************
#int_ext
void corte()
 {
    duty=0;
    grabar=1;         
 }
#int_CCP1
void  CCP1_isr(void) 
{ 
 cont++;
  if (cont==2)
  {
   contador=get_timer0();
   set_timer0(0);
   
   cont=0;
 //  if (rpm>600)
 //  {
    Segundos++;
    SegundosParcial++;
//  }
//*********Cuenta Horas Total**********************************/         
      if(Segundos == 60)
      { 
          Minuto++;
          Segundos=0; 
             
      if(Minuto == 60)
       {
          Hora++;
          Minuto=0;
       }
      }
/**********Cuenta Horas Parcial*********************************/ 
      if(SegundosParcial == 60)
      {           
          MinutoParcial++;
          SegundosParcial=0; 
             
      if(MinutoParcial == 60)
       {
         
          HoraParcial++;
          MinutoParcial=0;
       }
    }   
  }    
}
int menus(void)
{ 
return (menu+'1');
}
void leer_memoria()
{
         Hora=read_int16_eeprom(100);
         delay_ms(15);
         HoraParcial=read_int16_eeprom(110); 
         delay_ms(15);  
         Minuto=read_eeprom(120);
         delay_ms(15); 
         MinutoParcial=read_eeprom(130);
         delay_ms(15);
         mantenimiento=read_int16_eeprom(160);
         delay_ms(15);         
         service=read_int16_eeprom(150);
         delay_ms(15); 
         e=read_float_eeprom(140);
         delay_ms(15);
}
void cuenta_horas()
{  
      
         lcd_gotoxy(1,1);
         printf(lcd_putc,"Par  %05lu:%02u:%02u",HoraParcial,MinutoParcial,SegundosParcial);
          
         lcd_gotoxy(1,2);
         printf(lcd_putc,"Tot  %05lu:%02u:%02u",Hora,Minuto,Segundos);
}
void cuenta_vueltas()
{    
               
         RPM= contador*e;
         
         lcd_send_byte(0,1);
         delay_us(2);
         NumGran(RPM);          
         printf(lcd_putc,"RPM");
     
         delay_ms(300);  //aca iban 300ms                
         printf(lcd_putc," %04lu    ",RPM); 
     if ( Minuto>=mantenimiento&&mantenimiento>0)//ATENCION cambiar Minuto por horas
      {     
   
        lcd_gotoxy(13,1); 
        lcd_putc("Mant ");//
        delay_ms(500);
      }         
}
void back_light()
{
       if(input(PIN_c4))       //Regula el backlight del lcd
        { delay_ms(100);
          duty +=15;
         
          if (duty >1023){duty = 1023;}  
        }
       if(input(PIN_c5))       //Regula el backlight del lcd
        { delay_ms(100);
          duty -=15;
         
          if (duty > 1023){duty = 0;}  
        }
         lcd_gotoxy(1,1);
         printf(lcd_putc,"   BACK LIGHT   \n      %04lu     ",duty);         
         set_pwm2_duty(duty);
}
//***************************************************
void main()
{
    set_tris_a(0b00010000);
    output_a(0b00000000);
    set_tris_c(0b01111110);// 0 = salidas
    output_c(0b00000000);
    set_tris_b(0b00000001);
    output_b(0b00000000);
//********************pwm2************************************      
    setup_ccp2(CCP_PWM);
    setup_timer_2(T2_DIV_BY_16,255, 1);
    set_pwm2_duty(duty); 
//************************************************************    
    setup_adc_ports(NO_ANALOGS);    
    setup_timer_0(rtcc_ext_h_to_l | rtcc_div_2);
    setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
    setup_ccp1(CCP_COMPARE_RESET_TIMER);
    CCP_1 = 62500;
    set_timer1(0);
    set_timer0(0);
//******************INT EXT***********************************    
    enable_interrupts(int_ext);
    ext_int_edge(h_to_l); 
    enable_interrupts(INT_CCP1);
    enable_interrupts(GLOBAL);
//************************************************************    
    leer_memoria();           // Funcion para leer la memoria 
 
    lcd_init();
    NumGran_Init();       
    lcd_gotoxy(1,1);           
    lcd_putc(" RPM Y HORIMETRO ");           
    delay_ms(2000);               
    lcd_putc("\f");
 
 while(1)
    { 
     while(grabar==1)
      {
        write_int16_eeprom(100, Hora);
        write_int16_eeprom(110, HoraParcial);         
        write_eeprom(120, Minuto);
        write_eeprom(130, MinutoParcial);
        grabar=0; 
        lcd_putc("\f");           
        lcd_putc("    APAGANDO     ");           
        delay_ms(500);
       }
    while(grabar==0)
      {       
   if(flag==0)               //Si flag ==0 me desplazo por el menu principal
   {
        if (input(pin_c3))
       {   delay_ms(50);
       while(input(pin_c3));
       
           menu++;  
       if (menu>4) 
           menu=0;
       }
   }  
    if(flag==1)             //si pulso C6 dentro del case 5 flag==1
   {  
        if (input(pin_c3)) //Si flag ==1 me desplazo por la configuracion
       {   delay_ms(50);
       while(input(pin_c3));
       
           menu++;  
       if (menu>9)            
           menu=0;
       }     
       }
     
   switch (menu+1)
   {
     case  1:cuenta_vueltas();
             break;
             
     case  2:cuenta_horas();
             break;
 
     case  3 :          
              service=read_int16_eeprom(150);
              delay_ms(15);
              lcd_gotoxy(1,1);
              printf(lcd_putc,"Proximo Service \nA las:  %04lu Hs     ",service);
            
              break;
     case  4:
             back_light();
              break;                 
 
     case  5 : 
              lcd_gotoxy(1,1);
              printf(lcd_putc,"      MENU       \n   Pulse enter  ");
             if (input(pin_c6))
             { delay_ms(50);
              while(input(pin_c6));
              flag=1;
              menu+=1;
             }
              break;
              
              
     case  6 :
              lcd_gotoxy(1,1);
              printf(lcd_putc,"Programe Service \nHoras:  %04lu    ",b);
              
              if (input(pin_c4))    
             {    delay_ms(200);       // antirebote
                
                    b+=1;
                if(b>9999)b=9999;      
             }
             if (input(pin_c5))  // Pulsador que decrementa
             { delay_ms(200);
              
                    b-=1;
                if(b>9999)b=0 ;     
             }
             
             if (input(pin_c6))
             { delay_ms(50);
              while(input(pin_c6));            
               write_int16_eeprom(150, b);  
               delay_ms(25);
               service=read_int16_eeprom(150);
               delay_ms(15);
               mantenimiento=Minuto+service;//ATENCION cambiar Minuto por hora
               write_int16_eeprom(160,mantenimiento);  
               delay_ms(15);               
               mantenimiento=read_int16_eeprom(160); 
               delay_ms(15); 
               lcd_gotoxy(1,1);
               printf(lcd_putc,"Proximo Service  \nA las:  %04lu Hs    ",mantenimiento ) ; 
               delay_ms(2000);
             }
              break;
              
     case  7 :                               //CALIBRA RPM
              e=read_float_eeprom(140);
              delay_ms(15);
              RPM= contador*e;
              lcd_gotoxy(1,1);
              printf(lcd_putc,"Actual RPM %04lu       ",RPM);
              if (input(pin_c4)) 
             {   
                   delay_ms(200);                    
                   ajuste+=0.02;          // Incremento
             }
             if (input(pin_c5))
             {   
                 delay_ms(200);
                 ajuste-=0.02;        //Decremento  
             }              
             if (input(pin_c6))
             { delay_ms(50);
              while(input(pin_c6));            
               write_float_eeprom(140, ajuste);  
               delay_ms(15);  
             }               
              RPM= contador*ajuste;
              lcd_gotoxy(1,2);
              printf(lcd_putc,"Ajuste RPM %04lu       ",RPM);        
              break;
               
     case  8 :                                
              lcd_gotoxy(1,1);
              printf(lcd_putc,"   RESET TOTAL    ");
              lcd_gotoxy(1,2);
              printf(lcd_putc,"   %05lu:%02u:%02u  ",Hora,Minuto,Segundos);
              if (input(pin_c6)) // Reset de cuenta horas parcial
               {  delay_ms(50);
               while(input(pin_c6));
                  Hora=00000;
                  write_int16_eeprom(100, Hora);
                  delay_ms(15);
                  Minuto=00;
                  write_eeprom(120, Minuto);
                  delay_ms(15);
              }
              break;  
           
     case  9 :flag=0;
              lcd_gotoxy(1,1);
              printf(lcd_putc,"  RESET PARCIAL    ");
              lcd_gotoxy(1,2);
              printf(lcd_putc,"   %05lu:%02u:%02u  ",HoraParcial,MinutoParcial,Segundos);
              if (input(pin_c6)) // Reset de cuenta horasparcial
               {  delay_ms(50);
               while(input(pin_c6));
                  HoraParcial=00000;
                  write_int16_eeprom(110, HoraParcial);
                  delay_ms(15);               
                  MinutoParcial=00;
                  write_eeprom(130, MinutoParcial);
                  delay_ms(15);
               }
              break;               
               
     default  :
               menu=0;
               break;
   }        
 }         
    }

Bueno espero los comentarios .Saludos!!!!!

KILLERJC · « **Respuesta #64 en:** 31 de Octubre de 2015, 08:56:28 »

No vi demasiado el codigo, primero felicitarte por quitar tantos whiles... muchos while/do..while es un codigo normalmente es algo malo, hay excepciones. El unico lugar que usaria varios es un en RTOS por ejemplo, que tenes 1 por tarea + 1 del main.

Te respondo a tus preguntas:

Citar

Tengo partes dentro del switch (case 6,7,8,9 ) donde configuro parametros ,aca tambien tendría que hacer funciones fuera del main y luego llamarlas en los case ? tiene algun sentido ?

Las funciones te permiten que el codigo se mas legible y no un main super extenso en el que tenes que andar buscandole el "case ..." o si modifica o no tal cosa y sea dificil de ver. Por eso puse este codigo ( lo modifique un poco):

Código: C

while(1)
{
 
   switch(x) {
        case 0:
                Funcion0();  //Aca el codigo de lo que tenes dentro del while x==0
                x++;
                break;
        case 1:
                Funcion1();  //Aca el codigo de lo que tenes dentro del while x==1
                x++;
                break;
        case 2:
                Funcion2();  //Aca el codigo de lo que tenes dentro del while x==2
                x++;
                break;
        case 3:
                Funcion3();  //Aca el codigo de lo que tenes dentro del while x==3
                x++;
                break;
        case 4:
                Funcion4();  //Aca el codigo de lo que tenes dentro del while x==4
                x=1;
                break;
        default:
                x=1;    //x no termino con un valor correcto, hubo un problema, entonces lo pongo en el valor inicial que corresponda
                break;
     }
}

Entonces cuando miras rapidamente te das cuenta que cuando el case es 2 hace XX funcion y aumenta x para acceder al proximo. Y listo, si estas interesado en ver que hace esa funcion te vas alla. Observaras que todo lo relevante al procedimiento, es decir como avanza el programa esta alli. Sin interesarme en que hacen las funciones en si. A eso queria llegar con el switch y las funciones, lamento si no me explique bien antes.
Por supuesto esto es solo para una mejor comprension del codigo, aprender a separar pequeñas tareas, asi de esa forma se puede debuggear mejor cuando algo falla, etc, vos podes seguir como estabas haciendo pero creo que te daras cuenta que es mas simple de ver/analizar lo que puse arriba que un main Super largo con miles de cosas dentro. Ademas si por ejemplo tenes que Funcion2 escribe el LCD dado la bienvenida, y cuando lo probas justamente ESO no funciona, ya sabes que tenes que ver solamente la Funcion2 y te olvidas completamente del switch y esas cosas, el cual estaria bien programado. ¿ Se entiende a lo que voy con division de tareas ? Es mas lindo analizar / corregir una funcion de 20 lineas que una de 300 lineas.
Como esto NO es obligacion, por eso solo conteste de que si tenias un while como loop infinito nomas y no sobre esto en mi anterior respuesta.Ya que no esta mal, es solo hacerlo mas simple de ver/analizar/debuggear.

Por ahi si son muy cortas las funcioens ( 2 o 3 lineas ) realmente no vale la pena crear una funcion para eso, y conviene ponerla en el switch, pero si son ya de 10/15 lineas por ahi es mejor separarla,

Citar

Tengo dudas en las partes en las que leo la memoria ya sea para luego imprimir en pantalla o para hacer cuentas con ese dato es necesario siempre aclarar :service=read_int16_eeprom(150);antes de usarlo( en este caso service)o con que este declarado dentro del void main() ya esta y no tengo que volver a llamarlo?

Depende... si esta declarado DENTRO del main(), entonces solo vas a poder acceder desde el main(), si llamas a una funcion esa variable no va a estar declarada.
Lo que podes hacer es:
- Si usas la variable en varias funciones, es declararla fuera del main() asi queda como "global" de esa forma todos accederian a la misma variable
- O si unicamente la usas en la funcion esa y no te importa mas, sea por que la proxima ves que lo uses vas a leer de nuevo la eeprom, o no la vas a usar, la podes declarar dentro de la funcion.
Esto es lo que se conoce como scope en C

Código: C

int j;          //Variable con permanencia en la RAM, no se destruye, scope: File , cualquier funcion lo puede usar
 
main() {
        int i=2;                //Creada al entrar al main, se destruye cuando se sale , solo accesible dentro de todo el main, Scope = Funcion
        int m;
        if (ax=4) { 
                int i=3;        // Creado al entrar al if, no es lo mismo que la i de antes!, scope: Block ,   cuando salis del if se pierde
                i++;            // i = 4
        }
        funcion1();
        i--;                    // i = 1
}
 
funcion1(){
        int i=9;        // Creado al entrar a funcion1, al salir de funcion1 se destruye
        i++;            // i = 10
        j= 10;          // j = 10
        m=5;            // Error, m es una variable de main, aca no esta definida
}

Espero que quede mas claro. Y responda tu pregunta.

KILLERJC · « **Respuesta #65 en:** 31 de Octubre de 2015, 09:28:49 »

Te dejo esto solo para que lo veas... y por gusto, esto era a lo que me referia cuando decia que debias cambiar todo el programa para que sea mas rapido.

Ahora como estamos mas cerca de hacer algo realmente dinamico y no atrapado en delays sino como una maquina de estados, voy a darte este codigo para que lo veas ( tal ves me equivoque en algo pero es para que te des idea ). Nuevamente no es obligacion, solo para que VEAS

Código: C

int estadoviejo=1,estado=0;
 
while(1)
{
 
        if(grabar==1)
        {
                grabo_eeprom();
                grabar = 0;
        }
 
 
        if(botones_presionados())       //Tomo resultado de botones, si observas siempre se estan leyendo, no hay delays en medio, lo maximo que tardaria es si se cambia de estado y entra en alguna funcion, lo mismo con la grabacion de la eeprom
        {
                //Segun el boton presionado, pregunto el estado que esta y actuo acorde
                if(estado==2 && boton1_presionado())
                {
                        estado=2;       //Habilito la muestra de variables
                }
        }
 
 
        if(estado!=estadoviejo)         //Esto hace que se ejecute solo 1 ves!
        {
 
                switch(estado) {
                case 0:
                        Funcion0();     //Muestro en LCD Bienvenido, seteo a contador= 20
                        break;
                case 1:
                        Funcion1();     // Muestro en LCD el Autor, seteo contador = 10
                        break;
                case 2:
                        Funcion2();     // Muestra Menu
                        break;
                case 3:
                        Funcion3();     // Muestro estado de variables en el LCD, contador = 10
                        break;
                case 4:
                        Funcion4();
                        break;
                default:
                        estado=1;    
                        break;
                estadoviejo=estado;
        }
     
        if (contador!=0){               // Temporizador, en ves de usar un delay, estoy haciendo uso de las interrupciones del timer
                if(timer1_interrupcion_activado()) contador--;
                if (contador==0)
                {
                        estado++;       // Podria haber utilizado un array con el valor inicial del estado como indice y a donde apuntar el proximo estado, ejemplo proxestado=[1,2,3,3,4], si estoy en estado 0, el proximo seria el 1 segun mi array
                }
        }
 
}

Observa que el "delay" creado con el contador que hicimos lo unico que hace es contar interrupciones. Y no ejecuta codigo, solo cambia de "estado", los botones tambien, no ejecutan un codigo, solo cambian de estado. Lo unico que ejecuta codigo es la grabacion de la EEPROM, pero tambien podria haber ejecutado eso como un estado si quisiera. Si quisiera hacer que por ejemplo se refresque el LCD cada tanto, podria hacerlo de 2 formas.. Creando 2 switch, uno bajo el if de la diferencia de estado ( el anterior y el nuevo ) y otro sin este if, dejando el default sin nada. De esa forma uno mostraria y el otro no. O llevar el if dentro de cada case del switch. Ya que de nada sirve que escriba 100 veces "Bienvenida" al LCD. Tambien una cosa a notar es que NO se usan delays dentro de las funciones.

arielmdq · « **Respuesta #66 en:** 31 de Octubre de 2015, 15:34:10 »

Hola KILLERJC ,te agradezco mucho toda la explicacion !!!! de a poco voy entendiendo cada vez mas, estoy de acuerdo con que de esa manera es mas legible el codigo y facil de detectar errores,a medida que lo iba modificando me era mas agradable verlo .Entiendo todo lo que me explicas o casi todo ja ja ,seguramente te haré algunas preguntas con respecto al ultimo ejemplo que me mostras por que me intereso esa manera de hacerlo .Pero antes quiero hacerme un ejemplo con eso, para asimilarlo bien y hacer las preguntas correspondientes .Nuevamente muchisimas gracias!!!!! ya te daré noticias .
Saludos!!!

arielmdq

Hola Killerjc , vos sabes que estuve mirando mucho el ultimo ejemplo que me pasaste pero no logro entenderlo,se que lo hiciste para darme una idea pero me complique

hasta empecé a hacer un programita de ejemplo solo para aprender a usar esta manera de leer los botones y usar la interrupcion como temporizador pero estoy trabado y no lo entiendo .
A ver si te puedo ir preguntando por partes y si me puedo hacer entender :
Entiendo que creas una funcion que se llama botones_presionados();pero de que manera estaría leyendo varios botones dentro de la funcion, por ejemplo :
int botones_presionados()
{ if ( input(pin_C0))
estado++;
}
No me doy cuenta como sería.Supongo que con estado solo te desplazas dentro del switch .Para cambiar de estado no estarías usando solo un boton por que ponerlo dentro de la funcion.
Me confunde tambien que luego creas otra funcion que se llama: boton1_presionado();que hace esta funcion ? no estarías leyendo ya en la funcion anterior cual boton se presionó
Y esta la ultima, en la ultima parte del ejemplo (y aca me recibo de " el novato del año " )

.No entiendo como das el tiempo con esto:
'contador' es la variable que se incrementa con cada interrupcion osea que :

if (contador!=0) //si contador es distinto de 0 es decir que si se esta incrementando
{
if(timer1_interrupcion_activado())//Entra esta funcion pero Que debería hacer esta funcion ?

{
contador--; // Por que decrementa contador ? En que momento entra la funcion anterior para decrementar contador ?

if (contador==0) // Por que se incrementa estado cunado contador es == 0 ?
{
estado++; // esto se me mezcla con que 'estado' es la variable que se incrementa con los pulsadores por que ahora se incrementa cuando contador es 0

Todo lo anterior a este ejemplo ,te lo entendi a la perfeccion ,pero como veras de esto no case un palo

me interesaría aprender como se hace, pero tal vez este lejos de comprenderlo ,no lo se .Si te parece que hay otra manera en la que lo pueda entender o tal vez un ejemplo concreto soy todo ojos, y si es que esta implicito en esta explicacion ,pero soy muy cuadrado

. Puedo entenderlo e igualmente agradecerte por todo lo que me has ayudado

.No quiero complicarte
Saludos!!!

KILLERJC

El ejemplo fue bastante resumido.

El programa es simple, estaria siempre dando vueltas en el while, no ejecutaria lo del switch a no ser que exista un cambio en el estado.
Es decir el switch hace eso.

Ahora necesito algo que lo haga cambiar. En este caso tengo 2 formas.
- La primera es por tiempo, en caso que se necesite pasar un tiempo antes de mostrar otra cosa en el LCD por ejemplo, lo que hago es contar la cantidad de interrupciones de un timer, para ese tiempo, observaras que mientras el estado es el mismo ( no cambio ) el ciclo while sigue ejecutandose. Cuando llega a 0 el contador avanza al estado que sigue, en este caso para que sea mas simple solo le puse un simple estado+1.
- La segunda es por botones, esta va a depender del estado actual. Si por ejemplo estoy en el estado 5 que es un menu, y toco el boton 1 , entonces que pase al estado 9 por ejemplo, y si todo el 3 que pase al estado 10 y que lo muestre por un tiempo.

Respecto al codigo:

Código: C

if (contador!=0){               // Contador se selecciona apenas entra a cada estado, esto permite dar un "tiempo"
                if(timer1_interrupcion_activado()) contador--;     // Se activo la interrupcion del timer? Supongamos timer = 0.5s , con contador = 20 serian 10 segundos ( en realidad 9.5s)
                if (contador==0)           // Si llego a 0 es por que pasaron los "10 segundos"
                {
                        estado++;       // Simplificado pero paso al estado siguiente, esto va a depender del estado anterior, por simplicidad puse nomas estado++
                }
        }

Si no armo un ejemplo en el cual puedas grabarlo y probarlo.

arielmdq

Sigo sin entender esto : if(timer1_interrupcion_activado()) como es que preguntas si se activó la interrupcion

? yo entiendo que la interrupcion se activa cada vez que contador se incrementa ,no se estoy trabado che no me doy cuenta . Si pudieras hacer un ejemplito para probarlo te agradecería .
Saludos!!!

KILLERJC

Escribi mal la funcion, entendela a la funcion que se activa cuando desbordo el timer1, cuando pasaron 0.5s se activa eso.
Cuando tenga un tiempo hago un ejemplito masomenos simple

mariacontenis · « **Respuesta #71 en:** 18 de Marzo de 2020, 02:21:24 »

Hola a todos... Hoy modifique solo un poquito el código posteado para ponerlo sobre una lcd4x20 y se ve de maravilla.

Sin embargo quiero hacerlo como un cronometro por una necesidad propia, me gustaría que tuviera la siguiente presentación en la LCD ( 00:00 ) y así manejar un cronometro con el formato de ( mseg : seg ) pero encuentro complejo el lograrlo y por ello requiero de su ayuda y colaboración para lograrlo.

Pongo la librería NumGrand y agradezco su ayuda.

Código: C#

#rom  0x2100={28,30,30,30,30,30,30,28, //  Media barra lateral derecha.==> Esta quedo como quería
              7,15,15,15,15,15,15,7,  //  Media barra lateral izquierda.           ==> Esta quedo como quería
              31,31,0,0,0,0,0,0,       //  Barra superior sola.                          ==> Esta quedo como quería
              0,0,0,0,0,0,31,31,       //  Barra inferior sola                             
              31,31,0,0,0,0,31,31,     //  Barra superior e inferior.
              31,30,0,0,0,0,0,0,      //  Flecha Izquierda.
              0,0,0,0,0,0,30,31,    //  Flecha Derecha.
              0,0,0,0,0,0,0,0}         //  Vacio.             
                         
int8 Digito[4],Segmento[3],Linea;
const int16 Grilla[2][10]={{120,770,740,740,130,147,147,720,140,140},
                          {130,770,137,730,770,730,130,770,130,770}};
//llamada CGRAM a numeros = 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9
 
Void Desmembra (int16 Dato);
Void Obtiene_Segmento (int16 Dato);
Void NumGran_Init();
 
 
Void NumGran(int16 Numero)
{
   int Dig;
   Desmembra (Numero);
   for (Linea=1;Linea<3;++Linea)
   {
      switch (Linea)
      {
         Case 1: lcd_gotoxy(4,2); for (Dig=0;Dig<4;++Dig){
             Obtiene_Segmento (Grilla[0][Digito[Dig]]);
             printf(LCD_PUTC,"%C%C%C",Segmento[2],Segmento[1],Segmento[0]);
         } break;
         Case 2: lcd_gotoxy(4,3); for (Dig=0;Dig<4;++Dig){
            Obtiene_Segmento (Grilla[1][Digito[Dig]]);
            printf(LCD_PUTC,"%C%C%C",Segmento[2],Segmento[1],Segmento[0]);
         } break;
      }
   }
}
 
Void Desmembra (int16 Dato)      //Esta funcion obtiene el valor de los
{                             // digitos a enviar al display
   Digito[0] = Dato/1000; Dato = Dato%1000;
   Digito[1] = Dato/100;  Dato = Dato%100;
   Digito[2] = Dato/10;   Dato = Dato%10;
   Digito[3] = Dato;
}
 
Void Obtiene_Segmento (int16 Dato)  //Esta funcion obtiene el valor de los
{                                // segmentos a enviar al display
   Segmento[2] = Dato/100;  Dato = Dato%100;
   Segmento[1] = Dato/10;   Dato = Dato%10;
   Segmento[0] = Dato;
}
 
Void NumGran_Init()
{
   int8 posicion;
   lcd_send_byte(0x00,0x40);                 // apunta al inicio de la CGRAM y
   for(posicion=0;posicion<=63;++posicion)   //carga los caracteres en la CGRAM
   lcd_send_byte(1,Read_eeprom(posicion));   //traidos de la EEPROM del PIC
}

Bueno pues como agrego esos ( : ) entre números y mseg y seg?.

KILLERJC · « **Respuesta #72 en:** 18 de Marzo de 2020, 11:34:47 »

Bueno la parte "importante" que es imprimir los numeros va bien...

Lo que tenes que modificar es como mostrarlo. es decir deberias enviar 2 numeros desde una columna, por ejemplo desde la 1, esos numeros te ocuparian, la columna 1 al 6.
Luego la columna 7 poner los dos puntos. El cual si es la misma libreria (y observando la foto del inicio del post) es poner un punto arriba y un punto abajo, es decir repetirlo, luego necesitarias otros 6 columnas mas para tu miliseg. En total 13 columnas ...

Esto exige Varias cosas de modificar en la libreria.... Las ennumero y espero no olvidarme de alguna:

- Limitar en las funciones la cantidad de digitos, ya que no es necesario 4, solo 2 digitos es suficiente... Esto suponiendo que no vas a utilizar lo de poner numeros mas grandes que 99, ejemplo:

Código: C

Void Desmembra (int8 Dato)      
{                             
   if(Dato > 99 ) Dato = 99;
   Digito[0] = Dato/10;
   Digito[1] = Dato%10;
}

- Configura el código para iniciar desde la columna/fila a eleccion, (ya que tenes un display 4x20) algo asi:

Código: C

Void NumGran(int8 Numero, int8 Columna, int8 Fila)
{
  int Dig;
  Desmembra (Numero);
  for (Linea=0;Linea<2;++Linea)
  {
    lcd_gotoxy(Columna,Fila+Linea); 
    for (Dig=0;Dig<2;++Dig) {
      Obtiene_Segmento (Grilla[Linea][Digito[Dig]]);
      printf(LCD_PUTC,"%C%C%C",Segmento[2],Segmento[1],Segmento[0]);
    }
  }
}

(PD: Achique el codigo porque era posible hacerlo, no tenia sentido teniendo el for repetir el codigo)

De esa forma si quisiera imprimir 52:88 deberia hacer

Código: C

NumGran(52, 1, 2);
// Aca la funcion para imprimir el ":"
NumGran(88, 7, 2);

Esto tambien permite que puedas actualizar los mseg sin necesidad de los segundos.

- Modificar alguna de las flechas (que no vas a usar) para que queden como puntos De esa forma imprimirlos aparte.
- Crear la funcion para imprimir los puntos

Creo que eso seria todo... Por supuesto el codigo modificado NO esta probado y puede haber errores, ya que no lo probé, ni compile, simplemente lo modifique.
El resto queda en tus manos.

mariacontenis · « **Respuesta #73 en:** 19 de Marzo de 2020, 04:18:35 »

Mil Gracias KILLERJC por tu ayuda.

Intento el código así como me dices..

Código: C#

#rom  0x2100={28,30,30,30,30,30,30,28, //  Media barra lateral derecha.==> Esta quedo como quería
              7,15,15,15,15,15,15,7,  //  Media barra lateral izquierda.           ==> Esta quedo como quería
              31,31,0,0,0,0,0,0,       //  Barra superior sola.                          ==> Esta quedo como quería
              0,0,0,0,0,0,31,31,       //  Barra inferior sola                             
              31,31,0,0,0,0,31,31,     //  Barra superior e inferior.
              31,30,0,0,0,0,0,0,      //  Flecha Izquierda.
              0,0,0,0,0,0,30,31,    //  Flecha Derecha.
              0,0,0,0,0,0,0,0}         //  Vacio.             
                         
int8 Digito[4],Segmento[3],Linea;
const int16 Grilla[2][10]={{120,770,740,740,130,147,147,720,140,140},
                           {130,770,137,730,770,730,130,770,130,770}};
//llamada CGRAM a numeros = 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9
 
Void NumGran(int16 Numero, int16 Columna, int16 Fila);
Void Desmembra (int16 Dato);
Void Obtiene_Segmento (int16 Dato);
Void NumGran_Init();
 
 
Void NumGran(int16 Numero, int16 Columna, int16 Fila)
{
  int Dig;
  Desmembra (Numero);
  for (Linea=0;Linea<2;++Linea)
  {
    lcd_gotoxy(Columna,Fila+Linea); 
    for (Dig=0;Dig<2;++Dig) {
      Obtiene_Segmento (Grilla[Linea][Digito[Dig]]);
      printf(LCD_PUTC,"%C%C%C",Segmento[2],Segmento[1],Segmento[0]);
    }
  }
}
 
Void Desmembra (int16 Dato)      
{                             
   if(Dato > 99 ) Dato = 99;
   Digito[0] = Dato/10;
   Digito[1] = Dato%10;
}
 
Void Obtiene_Segmento (int16 Dato)  //Esta funcion obtiene el valor de los
{                                // segmentos a enviar al display
   Segmento[2] = Dato/100;  Dato = Dato%100;
   Segmento[1] = Dato/10;   Dato = Dato%10;
   Segmento[0] = Dato;
}
 
Void NumGran_Init()
{
   int8 posicion;
   lcd_send_byte(0x00,0x40);                 // apunta al inicio de la CGRAM y
   for(posicion=0;posicion<=63;++posicion)   //carga los caracteres en la CGRAM
   lcd_send_byte(1,Read_eeprom(posicion));   //traidos de la EEPROM del PIC
}

Dentro del While principal tengo esto:

Código: C#

lcd_send_byte(0,1); delay_us(2);  //limpiar LCD - Necesario si
         NumGran(Numero, 1, 3);
         NumGran(Numero, 7, 3);
         printf(lcd_putc,"%04lu",Numero);

Y los resultados son como los de la imagen en captura de pantalla, es decir, los (Seg : mSeg) corren al mismo tiempo los dos desde cero hasta 99.

Lo que realmente pretendo es al termino de los 99 mSeg inicien los segundos.

Algo asi: if(mSeg>99){ mSeg=0; Seg++}

Para que de esta manera se pueda hacer un cronometro.

KILLERJC · « **Respuesta #74 en:** 19 de Marzo de 2020, 09:02:09 »

Citar

corren al mismo tiempo los dos desde cero hasta 99.

y es obvio... ya que estas enviando siempre el mismo numero:

Código: C

NumGran(Numero, 1, 3);
         NumGran(Numero, 7, 3);

Fuera asi:

Código: C

NumGran(Msegundos, 1, 3);
         NumGran(Segundos, 7, 3);

Es otra cosa...

Ademas pretender que valla del 00 a 99 y lo puedas ver es otra cosa que no va a suceder, ya que los tiempos para manejar el LCD seguramente superen algunos milisegundos.

TODOPIC

Autor Tema: Ayuda con lcd (Leído 23569 veces)

arielmdq

Re:Ayuda con lcd

KILLERJC

Re:Ayuda con lcd

arielmdq

Re:Ayuda con lcd

arielmdq

Re:Ayuda con lcd

KILLERJC

Re:Ayuda con lcd

KILLERJC

Re:Ayuda con lcd

arielmdq

Re:Ayuda con lcd

arielmdq

Re:Ayuda con lcd

KILLERJC

Re:Ayuda con lcd

arielmdq

Re:Ayuda con lcd

KILLERJC

Re:Ayuda con lcd

mariacontenis

Re:Ayuda con lcd

KILLERJC

Re:Ayuda con lcd

mariacontenis

Re:Ayuda con lcd

KILLERJC

Re:Ayuda con lcd