Ejemplitos en C para 16F648A

[vszener]

Aqui os podeis descargar los archivos para el programa: contador descendente 9-0


Suerte!!!

[vszener]

Ya que sabemos contar del 0 al 9 y del 9 al 0 mediante el periferico 7 segmentos.....esta vez el ejemplito propuesto es incorporarle un switch por el porta(pin A0) y si dicho switch esta abierto el contador sera ascendente(del 0 al 9) y si esta cerrado el switch el contador sera descendente(del 9 al 0)....aqui el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"04      
//                     14/Agosto/05
//
//   Programa:   Contador reversible 0-9
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador reversible 0 al 9 viceversa cada 0,5s y vuelta a empezar. Tener
//         en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//         salida. Cuando el switch esta cerrado se lee por el pin A0 del porta un
//         "0" logico(pin A0 low)y el contador se configura como descendente encambio
//         si el switch esta abierto se lee por el pin A0 del porta un "1"
//         logico(pin A0 high) por lo tanto el contador se configura como ascendente
//
//   Conexiones:      A0 -> switch           a
//               B0 -> a 7seg         ____
//               B1 -> b 7seg      f  |    | b
//               B2 -> c 7seg         | g  |
//               B3 -> d 7seg            ----
//               B4 -> e 7seg      e  |    | c
//               B5 -> f 7seg           |____|
//               B6 -> g 7seg             d
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3,PIN_B4,PIN_B5,PIN_B6)
#use standard_io(A)

///DECLARACION DE FUNCIONES
void up(void);      //funcion cuenta ascendente
void down(void);   //funcion cuenta descendente

///DECLARACION VARIABLES GLOBALES
signed char i;   //contador para tabla 7 seg (se tiene en cuenta el signo)
int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9
      
///PROGRAMA
void main(void)
{
   set_tris_a(0xFF);            //porta como entrada   
   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas
///inicializamos el contador   
   if(!input(PIN_A0))      //para ello leemos el estado del pin A0 del porta
      i=10;            //contador descendente
   else
      i=-1;            //contador ascendente

   do{                        //bucle...
      if(input(PIN_A0))         //¿switch abierto?
         up();               //SI -> contador ascendente
      else
         down();               //NO -> contador descendente
         
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      delay_ms(500);
      }while(TRUE);            //...infinito         
}

void up(void)                  //funcion cuenta ascendente
{         
      i++;                  //incremento contador para visualizar siguiente digito
      if(i>9)                  //¿ya se ha mostrado el digito 9?
         i=0;               //SI -> vuelve a empezar(digito 0)         
}

void down(void)                  //funcion cuenta descendente
{
      i--;                  //decremento contador para visualizar siguiente digito
      if(i==-1)               //¿ya se ha mostrado el digito 0?
         i=9;               //SI -> vuelve a empezar(digito 9)
}

Ya tenemos nuestro contador reversible!!!

[vszener]

Aqui os podeis descargar los archivos para el contador reversible


Suerte!!!

[vszener]

Buenasss jeje!!!bien, aqui otro ejmeplito mas con el periferico 7seg...ya sabemos contar desde 0 a 9, desde 9 a 0 e incluso de 0 a 9 y viceversa!!!!!vamos a seguir contando jeje esta vez aqui un ejemplito de un contador desde 00 a 99 y vuelta a empezar...aqui el programita:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05      
//                     18/Agosto/05
//
//   Programa:   Contador del 00 al 99
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 00 al 99 cada 1s y vuelta a empezar. Tener en cuenta
//         que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//         Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar digito por 1º 7seg
//            * j -> indice tabla 7seg para mostrar digito por 2º 7seg
//            * flag -> variable que cuenta 1s
//            * var -> ajuste fino para que desborde cada segundo
//         Utilizamos la funcion de interrupcion para actualizar indices de la
//         tabla de 7seg para mostrar el digito correspondiente en el respectivo
//         7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
//         con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//         un desbordamiento de 1s utilizamos una variable(flag) que no entra en
//         la actualizacion de indices hasta transcurrido 1s.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1)   //A0,A1 como salidas en porta

char i=0,j=0,flag=0,var=20;   //variables globales

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 1 segundo?
      var--;         //SI -> decremento var...
      if(var<18)
         var=20;      //...ajuste fino de 1s
      flag=0;         //reset flag para contar 1s
      if(i>{      //¿se ha mostrado por 1º 7seg digito 9?
         i=0;      //SI -> i=0 (muestra digito 0) (*)
         j++;      //incremento indice j
         if(j>9){   //¿se ha mostrado por 2º 7seg digito 9?
            j=0;}   //SI -> j=0 (muestra digito 0)
            }
      else{         //(*) NO -> incrementa i
         i++;}
      }
   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9
   
   set_tris_b(0x00);                     //portb como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{                        //bucle...
      output_high(PIN_A1);      //2º 7seg off            
      output_low(PIN_A0);         //1º 7seg on
      delay_ms(15);            
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      output_low(PIN_A1);         //2º 7seg on            
      output_high(PIN_A0);      //1º 7seg off
      delay_ms(15);            
      output_b(tab7seg[ j ]);      //muestra por portb digito 7 segmentos            
      }while(TRUE);            //...infinito         
}

Decir que este ejemplito es bastante curioso aparte por manejar display"s de 7 segmentos multiplexados, por utilizar el TIMER0...es decir la cuenta de 1 segundo se hace atraves del desbordamiento del TMR0.....asi ya sabeis como programar interrupciones.....

[vszener]

Aqui os podeis descargar el ejemplo del contador ascendente 00 al 99


Suerte!!!

[vszener]

Recordar la formula para temporizaciones con los timers.....respecto al tmer de 8 bits(como es el caso del TMR0), esta es la formula a seguir:

Temporizacion = Tcm · Prescaler · (256-Carga TMR0)

Tcm = 4·Tosc = 4· 1/f         ;f=frecuencia del cristal
Carga TMR0 = valor cargado a principio el el TMR0 como es de 8 bits 2^8=256 pero si se carga con 256 la temporizacion es cero...por lo tanto el valor del Carga del TMR0 debe estar comprendido entre [0,255]

Bueno aqui un pequeñisimo recuerdo de como funciona los timers....

[vszener]

Aqui estamos de nuevo!!!jeje ya que sabemos contar desde 0 al 99, ¿porque no contar desde 99 a 00?ummmm pero de forma automatica, es decir, nuestro contador empezara a contar de forma ascendente de 00 a 99 y cuando alcance el digito 99 que empiece a contar de forma descendente de 99 a 00 y vuelta a empezar!!!! aqui va el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05      
//                     22/Agosto/05
//
//   Programa:   Contador del 00 al 99 y viceversa automaticamente
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 00 al 99 cada 1s y vuelta a empezar. Tener en cuenta
//         que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//         Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar digito por 1º 7seg
//            * j -> indice tabla 7seg para mostrar digito por 2º 7seg
//            * flag -> variable que cuenta 1s
//            * var -> ajuste fino para que desborde cada segundo
//            * cuenta -> cuenta=0 -> Contador ascendente ; cuenta=1 -> Contador descendente
//         Utilizamos la funcion de interrupcion para actualizar indices de la
//         tabla de 7seg para mostrar el digito correspondiente en el respectivo
//         7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
//         con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//         un desbordamiento de 1s utilizamos una variable(flag) que no entra en
//         la actualizacion de indices hasta transcurrido 1s. Configuramos una
//         variable tipo short,bit, llamada "cuenta" que si vale 1 significa que
//         el contador es descendente y si vale 0 significa que el contador es ascendente.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1)   //A0,A1 como salidas en porta

//VARIABLES GLOBALES
signed char i=0,j=0;   //indices(se tiene en cuenta signo para comprobaciones de fin tab7seg)
char flag=0,var=20;   
short cuenta=0;         //cuenta=0 -> Contador ascendente ; cuenta=1 -> Contador descendente

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 1 segundo?rutina:actualizar indices y contador ascendente/descendente
      var--;         //SI -> decremento var...
      if(var<18)
         var=20;      //...ajuste fino de 1s
      flag=0;         //reset flag para contar 1s
      if(cuenta==0){   //¿Contador ascendente?
      if(i>{      //SI -> ¿se ha mostrado por 1º 7seg digito 9?
         i=0;      //SI -> i=0 (muestra digito 0) (*)
         j++;      //incremento indice j
         if(j>9){      //¿se ha mostrado digito 99?
            cuenta=1;   //SI -> contador descendente...
            j=9;      //restauro...
            i=8;      //...indices
            }   
         }
      else{         //(*) NO -> incrementa i
         i++;}
      }
      else{               //Contador descendente
         i--;            //decremento indice i
         if(i<0){         //¿fin tab7seg en indice i?
            i=9;         //SI -> restauro i
            j--;         //decremento indice j
            if(j<0){      //¿fin tab7seg en indice j 00?
               cuenta=0;   //SI -> Contador descendente
               i=1;      //restauro...
               j=0;      //...indices
               }
            }
         }
      } //fin actualizar indices y contador ascendente/descendente
   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9
   
   set_tris_b(0x00);                     //portb como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{                        //bucle...
      output_high(PIN_A1);      //2º 7seg off            
      output_low(PIN_A0);         //1º 7seg on
      delay_ms(15);            
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      output_low(PIN_A1);         //2º 7seg on            
      output_high(PIN_A0);      //1º 7seg off
      delay_ms(15);            
      output_b(tab7seg[ j ]);      //muestra por portb digito 7 segmentos            
      }while(TRUE);            //...infinito         
}

Hasta el siguiente ejemplito!!!

[vszener]

Aqui os podeis descargar los archivos en .c, .hex y .dsn del ejemplo: Contador del 00 al 99 y viceversa de forma automatica


Suerte!!!

[vszener]

Misteriosamente este programa no estaba....asi que lo pongo de nuevo(simplemente estaba su descarga...), es un contador ascendente bcd que cuenta pulsando el boton:

Código: C

1. ////////////////////////////////////////////////////////////////////////////////////
2. //                                                      VsZeNeR'05             
3. //                                                 22/Agosto/05
4. //                                                      vszener@gmail.com
5. //      Programa:       Contador 0-9 display BDC & Boton
6. //      Version:        0.0
7. //
8. //      Dispositivo: PIC 16F648A                        Compilador:      CCS vs3.227
9. //      Entorno IDE: MPLAB IDE v7.20            Simulador:       Proteus 6.7sp3
10. //
11. //      Notas: Contador 0 al 9 cada vez que pulsemos el boton y vuelta a empezar. Tener
12. //                 en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
13. //                 salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
14. //                 que este dispositivo genera 'rebotes' que hay que ser eliminados para
15. //                 una correcta visualizacion en el display del digito seleccionado. Esta vez
16. //                 la eliminacion de 'los rebotes' se ha realizado mediante software.
17. //                 Cuando por el pin A0 del porta se introduce un '0' logico(low), se
18. //                 incrementa un digito en el display BCD.
19. //
20. //      Conexiones:             A0 -> boton                  
21. //                                      B0 -> a
22. //                                      B1 -> b
23. //                                      B2 -> c
24. //                                      B3 -> d
25. //      BCD:
26. //                              d c b a   NUM
27. //                              0 0 0 0    0
28. //                              0 0 0 1    1
29. //                              0 0 1 0    2
30. //                              0 0 1 1    3
31. //                              0 1 0 0    4
32. //                              0 1 0 1    5
33. //                              0 1 1 0    6
34. //                              0 1 1 1    7
35. //                              1 0 0 0    8
36. //                              1 0 0 1    9
37. //////////////////////////////////////////////////////////////////////////////////
38.  
39. #include <16f648a.h>                            //pic a utilizar                       
40. #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP             //ordenes para el programador
41. #use delay (clock=4000000)                      //Fosc=4Mhz
42. #use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
43. #use standard_io(A)
44.                
45. ///PROGRAMA
46. void main(void)
47. {
48.         char i=0;       //contador para tabla BCD
49.         int tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001}; //BCD 0-9
50.                
51.         set_tris_a(0xFF);                               //porta como entrada   
52.         disable_interrupts(GLOBAL);             //todas las interrupciones desactivadas
53.        
54.         output_b(tabBCD[i]);                    //inicializa displayBCD digito 0
55.  
56.         for(;;){                                                //bucle...
57.                 if(!input(PIN_A0))                      //¿se ha pulsado el boton?
58.                         {
59.                                 delay_ms(151);          //SI -> retardo para evitar los rebotes
60.                                 i++;                            //incremento contador indice tabBCD
61.                                 if(i>9)                         //¿se ha mostrado digito 9?
62.                                         i=0;                    //SI -> restaura valor indice(para mostrar digito 0)
63.                                 output_b(tabBCD[i]); //muestra por portb digito 7 segmentos
64.                         }                      
65.                 }                                                       //...infinito
66. }

Suerte!!!

[vszener]

Y aqui va la version de contador de 0a9 en display de 7 segmento formato BCD y boton...peo esta vez dos botones, uno por el pin A0 que sis e pulsa se incrementa un digito y s emuestra por el 7seg BCD y otro boton por el pin A1 que si se pulsa se decrementa en una unidad y s emuestra por display de 7seg BCD:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05      
//                     22/Agosto/05
//
//   Programa:   Contador 0-9 display BDC & Boton para cuenta ascendente o descendente
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador 0 al 9 cada vez que pulsemos el boton y vuelta a empezar. Tener
//         en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//         salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
//         que este dispositivo genera "rebotes" que hay que ser eliminados para
//         una correcta visualizacion en el display del digito seleccionado. Esta vez
//         la eliminacion de "los rebotes" se ha realizado mediante software.
//         Cuando por el pin A0 del porta se introduce un "0" logico(low), se
//         incrementa un digito en el display BCD, encambio si por el pin A1 se introduce
//         un "0" logico(low) se decrementa en una unidad el digito a mostrar.
//
//   Conexiones:      A0 -> boton   up(cuenta ascendente)
//               A1 -> boton down(cuenta descendente)         
//               B0 -> a
//               B1 -> b
//               B2 -> c
//               B3 -> d
//   BCD:
//            d c b a   NUM
//            0 0 0 0    0
//            0 0 0 1    1
//            0 0 1 0    2
//            0 0 1 1    3
//            0 1 0 0    4
//            0 1 0 1    5
//            0 1 1 0    6
//            0 1 1 1    7
//            1 0 0 0    8
//            1 0 0 1    9
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)
      
///PROGRAMA
void main(void)
{
   signed char i=0;   //contador para tabla BCD
   int tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001};   //BCD 0-9
      
   set_tris_a(0xFF);            //porta como entrada   
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas
   
   output_b(tabBCD[ i ]);         //inicializa displayBCD digito 0

   for( ; ; ){                  //bucle...
      if(!input(PIN_A0))         //¿se ha pulsado el boton up?
         {
            delay_ms(151);      //SI -> retardo para evitar los rebotes
            i++;            //incremento contador indice tabBCD
            if(i>9)            //¿se ha mostrado digito 9?
               i=0;         //SI -> restaura valor indice(para mostrar digito 0)
         }
      if(!input(PIN_A1))         //¿se ha pulsado el boton down?
         {
            delay_ms(151);      //SI -> retardo para evitar los rebotes
            i--;            //decremento contador indice tabBCD
            if(i<0)            //¿se ha mostrado digito 0?
               i=9;         //SI -> restaura valor indice(para mostrar digito 9)
         }
      output_b(tabBCD[ i ]);       //muestra por portb digito BCD         
      }                     //...infinito
}
Recordad que los botones generan los llamados "rebotes" que deben ser eliminados bien hardware o bien por software(el cual es este ejemplo mediante una pausa de 151ms)....corto y cambio!!!

[vszener]

De este enlace os podeis bajar los archivos del ejemplo anterior: contador 0a9 en 7seg BCD con dos botones uno ascendente y otro descendente:


Suerte!!!

[vszener]

Bueno celebrando mi mensaje numero 100!!!(parece que fue ayer...)aqui un ejemplito massss de contador en display"s de 7seg...ya se que estais cansados de ver numeritos y mas numeritossss jeje pero weno asi ya sabemos programar display"s de 7seg multiplexados, interrupciones y demas cositas...esta vez es un SUPER CONTADOR!!!!!jeje ascendente(de momento) que cuenta de 0000 a 9999 y vuelta a empezar....bueno compañeros, ya no hay excusa que no sabemos contar!!!!:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05      
//                     23/Agosto/05
//
//   Programa:   Contador del 0000 al 9999
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 0000 al 9999 cada 1s y vuelta a empezar. Tener en cuenta
//         que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//         Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar digito por 1º 7seg
//            * j -> indice tabla 7seg para mostrar digito por 2º 7seg
//            * w -> indice tabla 7seg para mostrar digito por 3º 7seg
//            * z -> indice tabla 7seg para mostrar digito por 4º 7seg
//            * flag -> variable que cuenta 1s
//            * var -> ajuste fino para que desborde cada segundo
//         Utilizamos la funcion de interrupcion para actualizar indices de la
//         tabla de 7seg para mostrar el digito correspondiente en el respectivo
//         7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
//         con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//         un desbordamiento de 1s utilizamos una variable(flag) que no entra en
//         la actualizacion de indices hasta transcurrido 1s.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RA2 -> Display 3º 7seg
//         · RA3 -> Display 4º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3)   //A0,A1,A2,A3 como salidas en porta

char i=0,j=0,w=0,z=0,flag=0,var=20;   //variables globales

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){            //¿ya es 1 segundo?
      var--;               //SI -> decremento var...
      if(var<18)
         var=20;            //...ajuste fino de 1s
      flag=0;               //reset flag para contar 1s
      if(i>{            //¿se ha mostrado por 1º 7seg digito 9?
         i=0;            //SI -> i=0 (muestra digito 0) (*)
         j++;            //incremento indice j
         if(j>9){         //¿se ha mostrado por 2º 7seg digito 9?
            j=0;          //SI -> j=0 (muestra digito 0)
            w++;         //incremento indice w
            if(w>9){      //¿se ha mostrado por 3º 7seg digito 9?
               w=0;      //SI -> w=0 (muestra digito 0)
               z++;      //incremento indice z
               if(z>9)      //¿se ha mostrado por 4º 7seg digito 9?
                  z=0;   //SI -> z=0 (muestra digito 0)
               }
            }
            }
      else{         //(*) NO -> incrementa i
         i++;}
      }
   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9
   
   set_tris_b(0x00);                     //portb como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{                        //bucle...
      output_high(PIN_A0);      
      output_high(PIN_A1);
      output_high(PIN_A2);
      output_low(PIN_A3);         //activado...
      output_b(tab7seg[ i ]);      //...1º 7seg
      delay_ms(10);
      output_high(PIN_A0);
      output_high(PIN_A1);      
      output_low(PIN_A2);         //activado...
      output_high(PIN_A3);      
      output_b(tab7seg[ j ]);      //...2º 7seg
      delay_ms(10);
      output_high(PIN_A0);
      output_low(PIN_A1);         //activado...
      output_high(PIN_A2);      
      output_high(PIN_A3);      
      output_b(tab7seg[ w ]);      //...3º 7seg
      delay_ms(10);
      output_low(PIN_A0);         //activado...
      output_high(PIN_A1);
      output_high(PIN_A2);
      output_high(PIN_A3);      
      output_b(tab7seg[ z ]);      //...4º 7seg
      delay_ms(10);               
      }while(TRUE);            //...infinito         
}

Mi mensajee numero 100 ole!!!!!

[vszener]

Aqui la direccion para descargarse los archivos .c, .hex y .dsn del ejemplito anterior: contador ascendente de 0000 a 9999:


Suerte!!!

[vszener]

Este ejemplito de hoy es para animar al BETI!!!aunque perdiera la supercopa españa....ainsss, el programa consiste en 7 display"s de 7seg multiplexados parpadeando la palabra "beti":

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05      
//                     24/Agosto/05
//
//   Programa:   BETI parpadeo
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Muestra el mensaje de BETI por cuatro display"s de 7 segmentos
//         multiplexados. El mensaje aparece cada 0,5s parpadeando
//         Tener en cuenta que hay que poner la directiva NOLVP
//         para que el pin B4 sea de salida.
//         Se utiliza variables locales:
//            * i -> contador para visualizar BETI
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RA2 -> Display 3º 7seg
//         · RA3 -> Display 4º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use standard_io(A)

///PROGRAMA
void main(void)
{
   char i;                     //contador de visualizacion BETI
   
   set_tris_b(0x00);            //portb como salida
   set_tris_a(0x00);            //porta como salida
   disable_interrupts(GLOBAL);      //activadas interrupciones

   do{                        //bucle...
      for(i=0;i<15;i++){         //bucle visualizacion beti         
      output_a(0b1110);         
       output_b(0x7C);            //1º 7seg on B
      delay_ms(10);
      output_a(0b1101);      
      output_b(0x79);            //2º 7seg on E
      delay_ms(10);
      output_a(0b1011);      
      output_b(0x78);            //3º 7seg on T
      delay_ms(10);
      output_a(0b0111);      
      output_b(0x30);            //4º 7seg on I
      delay_ms(10);
      }
      
      output_b(0x00);            //todo...
      output_a(0b0000);
      delay_ms(500);            //...apagado durante 0,5s            
      }while(TRUE);            //...infinito         
}

Musho betiii man ke pierda!!!!jeje

PD: Aunque yo soy del Depor.....

[vszener]

Desde este enlace os podeis descargar los archivos necesarios para el programa anterior del parpadeo de la palabra Beti en 4 display"s de 7seg multiplexados


Suerte!!!