[SRC]Librería int16/float to Display7seg CCS

[beto1234]

 Hola amigos, quiero compartir con ustedes esta librería para mandar un valor int16 a un display de 7 segmento x 3.
 Más adelante voy a hacer uno para poder mandar un valor con coma flotante (FLOAT).

• LIBRERIA.[/b]
  
  Código: C
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //                                                                           //
  3. // Driver file for Display7segmentos multiplexado por 3                      //
  4. //                                                                           //  
  5. // Function : ToDisplay(valor);                                              //
  6. // Return   : none                                                           //
  7. //                                                                           //
  8. // By Alberto Andres Robledo Sánchez, Alumno: UTN-FRRE                       //
  9. // www.chacoelecnor.com.ar                                                   //
  10. //                                                                           //
  11. //                           CONEXIÓN                                        //
  12. // A->RC6,B->RC5,C->RC4,D->RC3,E->RC2,F->RC1,G->RC0 , DP->RC7                //
  13. // TRANSITOR1->RB1, TRANS2->RB2, TRANS3->RB3                                 //
  14. ///////////////////////////////////////////////////////////////////////////////
  15. #use fast_io(B)
  16. #use fast_io(C)
  17. #DEFINE   Q1   PIN_B1                   // transistor 1
  18. #DEFINE   Q2   PIN_B2                   // transistor 2
  19. #DEFINE   Q3   PIN_B3                   // transistor 3
  20. #DEFINE   punto   PIN_C7                   // punto decimal
  21. #BYTE    salida=0x07 // puerto C
  22.  
  23.  
  24.  
  25. //************************************************************************************
  26.    struct digitos_separados {         // variables en bcd de unidad,decena,centena
  27.       int  unidad, decena, centena;
  28.    } digito;
  29. //************************************************************************************
  30.    struct mis_datos {                 // variables de datos de entrada y salida
  31.       int16  dato1, dato2, resultado;
  32.    } numeros;
  33. //************************************************************************************
  34.    void separar_digitos(){      // separa resultado en unidad, decena y centena
  35.      int16   temp;
  36.      digito.unidad=0;
  37.      digito.decena=0;
  38.      digito.centena=0;
  39.      temp=numeros.resultado;
  40.      while(temp>=100){
  41.        temp-=100;
  42.        digito.centena++;
  43.      }
  44.      while(temp>=10){
  45.        temp-=10;
  46.        digito.decena++;
  47.      }
  48.      digito.unidad=temp;
  49.    }
  50. //************************************************************************************
  51.    void mostrar(){               // multiplexa en tres display 7-seg anodo común
  52.       int const bcd_7seg[10]= {0x7e,0x30,0x6d,0x79,0x33,0x5b,0x5f,0x70,0x7f,0x73};
  53.       int contador;
  54.       output_low(Q1);
  55.       output_low(Q2);
  56.       output_low(Q3);
  57.       //output_low(punto);
  58.     for(contador=0;contador<11;contador++){
  59.          salida=bcd_7seg[digito.unidad];           // muestra unidad
  60.          output_high(Q1);
  61.          delay_ms(5);
  62.          output_low(Q1);
  63.          delay_cycles(4);
  64.          salida=bcd_7seg[digito.decena];           // muestra decena
  65.          output_high(Q2);
  66.          delay_ms(5);
  67.          output_low(Q2);
  68.          delay_cycles(4);
  69.          salida=bcd_7seg[digito.centena];           // muestra centena
  70.          output_high(Q3);
  71.          //output_high(punto);
  72.          delay_ms(5);
  73.          output_low(Q3);
  74.          //output_low(punto);
  75.          delay_cycles(4);
  76.       }
  77.     }
  78.    
  79. void ToDisplay (long value)
  80. {
  81. set_tris_b(0x0);             // puertob=salida
  82. set_tris_c(0x0);             // puertoc=salida
  83. numeros.resultado=(int16)(value);
  84. separar_digitos();
  85. mostrar();
  86. }
  
  
  
  • EJEMPLO DE USO[/b]
    
    Código: C
    1. #include <16F873.h>
    2.    #device ADC=10
    3.    #use delay(clock=4000000)
    4.    #fuses NOCPD,NOWDT,BROWNOUT,PUT,XT,NOWRT,NOLVP,NODEBUG,NOPROTECT //0x3F71
    5.    #include <Int16_to_3Display7seg.c>
    6.  
    7. //************************************************************************************
    8. // RUTINA PRINCIPAL
    9. //***************************************//
    10. void main(){
    11.    
    12. Bucle:
    13.    ToDisplay(458);// envia 458 al display
    14.    
    15.    goto  Bucle;
    16. }
    17. //****************************************
    
    
    

[Nocturno]

Gracias por compartirlo

[Suky]

Te tiro algunas ideas Primero que nada en C hay que olvidarse del goto  Después, pensando en que se necesite mostrar el numero en un display pero realizar varias otras tareas, podes implementar una librería que ocupe un timer para que, por ejemplo, interrumpa cada 5ms y actualice los display. Una rutina corta que permita trabajarlo en "segundo" plano y realizar otras tareas sin mayores inconvenientes.


Saludos!

[beto1234]

 Hola muchas gracias. Suky mira yo estaba por intentar hacer con RTOS, pero no lo hice para que el código pueda ser lo mas fácil posible de entender.
 Acá dejo como enviar un Float al display 7 segmentos multiplexado por 4.
 
LIBRERIA

Código: C

1. ///////////////////////////////////////////////////////////////////////////////
2. //                                                                           //
3. // Driver file for Display7segmentos multiplexado por 4                      //
4. //                                                                           //  
5. // Function : ToDisplay(valor);                                              //
6. // Return   : none                                                           //
7. //                                                                           //
8. // By Alberto Andres Robledo Sánchez, Alumno: UTN-FRRE                       //
9. // www.chacoelecnor.com.ar                                                   //
10. //                                                                           //
11. //                           CONEXIÓN                                        //
12. // A->RC6,B->RC5,C->RC4,D->RC3,E->RC2,F->RC1,G->RC0 , DP->RC7                //
13. // TRANSITOR1->RB1, TRANS2->RB2, TRANS3->RB3 , TRANS4->RB4                   //
14. ///////////////////////////////////////////////////////////////////////////////
15. #use fast_io(B)
16. #use fast_io(C)
17. #DEFINE   Q1   PIN_B1                   // transistor 1
18. #DEFINE   Q2   PIN_B2                   // transistor 2
19. #DEFINE   Q3   PIN_B3                   // transistor 3
20. #DEFINE   Q4   PIN_B4                   // transistor 4
21. #DEFINE   punto   PIN_C7                   // punto decimal
22. #BYTE    salida=0x07 // puerto C
23.  
24.  
25.  
26. //************************************************************************************
27.    struct digitos_separados {         // variables en bcd de unidad,decena,centena
28.       int  unidad, decena, centena, cifraco;
29.    } digito;
30. //************************************************************************************
31.    struct mis_datos {                 // variables de datos de entrada y salida
32.       int16  dato1, dato2, resultado;
33.    } numeros;
34. //************************************************************************************
35.    void separar_digitos(){      // separa resultado en unidad, decena y centena
36.      int16   temp;
37.      digito.unidad=0;
38.      digito.decena=0;
39.      digito.centena=0;
40.      temp=numeros.resultado;
41.      while(temp>=100){
42.        temp-=100;
43.        digito.centena++;
44.      }
45.      while(temp>=10){
46.        temp-=10;
47.        digito.decena++;
48.      }
49.      digito.unidad=temp;
50.    }
51. //************************************************************************************
52.    void mostrar(){               // multiplexa en tres display 7-seg anodo común
53.       int const bcd_7seg[10]= {0x7e,0x30,0x6d,0x79,0x33,0x5b,0x5f,0x70,0x7f,0x73};
54.       int contador;
55.       output_low(Q1);
56.       output_low(Q2);
57.       output_low(Q3);
58.       //output_low(punto);
59.     for(contador=0;contador<11;contador++){
60.          salida=bcd_7seg[digito.unidad];           // muestra unidad
61.          output_high(Q1);
62.          output_high(punto);
63.          delay_ms(5);
64.          output_low(Q1);
65.          output_low(punto);
66.          delay_cycles(4);
67.          salida=bcd_7seg[digito.decena];           // muestra decena
68.          output_high(Q2);
69.          delay_ms(5);
70.          output_low(Q2);
71.          delay_cycles(4);
72.          salida=bcd_7seg[digito.centena];           // muestra centena
73.          output_high(Q3);
74.          delay_ms(5);
75.          output_low(Q3);
76.          delay_cycles(4);
77.          salida=bcd_7seg[digito.cifraco];           // muestra cifraco
78.          output_high(Q4);
79.          delay_ms(5);
80.          output_low(Q4);
81.          delay_cycles(4);
82.       }
83.     }
84.    
85. void ToDisplay (float  value)
86. {
87. int16   a;
88. float cifra;
89. a=(int16)value;
90. cifra=value-(float)a;
91. digito.cifraco=(int)((10.0*cifra)+0.5);
92. set_tris_b(0x0);             // puertob=salida
93. set_tris_c(0x0);             // puertoc=salida
94. numeros.resultado=(int16)(value);
95. separar_digitos();
96. mostrar();
97. }

EJEMPLO

Código: C

1. // *- 4 displays 7-seg cátodo común
2.  
3.    #include <16F873.h>
4.    #device ADC=10
5.    #use delay(clock=4000000)
6.    #fuses NOCPD,NOWDT,BROWNOUT,PUT,XT,NOWRT,NOLVP,NODEBUG,NOPROTECT //0x3F71
7.    #include <float_to_4Display7seg.c>
8.  
9. //************************************************************************************
10. // RUTINA PRINCIPAL
11. //***************************************//
12. void main(){
13.    
14. Bucle:
15.    ToDisplay(458.6);// envia 458.6 al display
16.    
17. goto  Bucle;
18. }
19. //****************************************

[MerLiNz]

otra forma mas sencilla y menos complicada seria meterlo en un array de char como string. Por ejemplo arr[]={"234"};

ahora para obtener el numero seria:

numero=arr[0]-48; //centenas
numero2=arr[1]-48; //decenas...

para el flotante, cuestion de poner un if (arr

• =='.') muestrapunto;

Que necesitamos meter una variable tipo int al array, pues utilizamos nuestro amigo itoa() o ltoa(), para saber la longitud de la string: strlen()

[beto1234]

MerLiNz. Interesante  , me gustaría ver algo más. 

[Suky]

Que necesitamos meter una variable tipo int al array, pues utilizamos nuestro amigo itoa() o ltoa(), para saber la longitud de la string: strlen()

Para eso revisa la ayuda del compilador 

[MerLiNz]

yo os doy la idea, si la aplicas veras que es mucho mas sencillo. Cuando metes numeros en una string estos numeros estan en ascii, si sabemos que el 0=ascii 48; entonces: array[0]-48 te daria el numero, 1=49, 2=50....

seria algo como

x=strlen(&array[0]);
unidades=array

• -48;

decenas=array[x-1]-48;

todo esto comprobando que cuando la x == 0 estamos en el ultimo numero.