Decodificador de binario a decimal

[QuijotescoXp]

Como le comenté a biblioman he hecho una revisión del decodificador que se propone en las practicas.

De esta manera dispondremos de perspectivas diferentes de hacer una misma cosa.

Adjunto los proyectos realizado con PCW y con el proteus para que veáis su funcionamiento.

Sería bueno comentar que os parece, tanto las dudas como las críticas constructivas.

Saludos a todos.

[biblioman]

Hola QuijotescoXp. Primeramente darte las gracias por aportar, tú versión del decodificador binario decimal mejora indudablemente la versión que puse al principio. Solo comentarte un par de cosas que he visto para optimizar a un más si cabe tú versión:

La primera es que si utilizas la función “input_a()” deberías de incluir la directiva #use fast_io(PUERTO), con esto se consigue reducir el código ASM después de compilar, es lo que intente explicar aquí.

Tú ejemplo tal y como está después de compilar me sale:
ROM 68 words
RAM 5

Después de incluir la directiva #use fast_io(A) y compilar de nuevo queda:
ROM 64 words
RAM 5

La segunda cosa que he visto es que en este ejemplo en concreto, se puede quitar la sentencia default , como solo tenemos tres interruptores solo podemos hacer 8 combinaciones (del 0 al 7), todas ellas ya están contempladas en las sentencias CASE por lo que el programa funcionará igual sin el DEFAULT.

Tú programa si me permites quedaría de la siguiente forma:

Código: Seleccionar todo

/******************************************************************************       
*                                                                             *
*  AUTOR      : QuijotescoXp                                                  *
*                                                                             *
*  EMAIL      : lrecueo1@alumno.uned.es                                       *
*                                                                             *
*  FECHA      : 26/09/09                                                      *
*                                                                             *
*  MICRO      : PIC 16F84A                                                    *
*                                                                             *
*  FUSES      : NOWDT                                                         *
*                                                                             *
*  OSC        :   XT                                                          *
*                                                                             *
*  LICENCIA   : GPL                                                           *
*                                                                             *
*  DESCRIPCIÓN: Decodificador de binario a decimal                            *
*                                                                             *
******************************************************************************/

#include <16F84A.h>
#use   delay( clock=4000000 )
#fuses XT, NOWDT
#byte  port_B = 0x06    // Dirección del port B.
#use fast_io(A)

void main()
{
   set_tris_b( 0x00 );  // Se configura port B como salida.
   set_tris_a( 0x1F );  // Se configura port A como entrada
                     
   port_B = 0x00;       // Ningún segmento a ON
   
   while( true )
   {     
      switch( input_a() )
      {
      case 0:
         port_B = 0x7E;
         break;
      case 1:
         port_B = 0x30;
         break;
      case 2:
         port_B = 0x57;
         break;
      case 3:
         port_B = 0x73;
         break;
      case 4:
         port_B = 0x39;
         break;
      case 5:
         port_B = 0x6B;
         break;
      case 6:
         port_B = 0x2F;
         break;
      case 7:
         port_B = 0x70;
         break;
   
      }
   }
}

Si volvemos a compilar tendremos:
ROM 56
RAM 5

Nota: cuando vi tú post ya había hecho otra versión del ejemplo, que es esta:

Código: Seleccionar todo


/*-------------------------------------------------------------------*\
|  DECODIFICAOR BINARIO A DECIMAL. Utilizando switch()|
|  Autor: biblioman    www.aquihayapuntes.com               |
\*-------------------------------------------------------------------*/
#include <16F84A.h>
#use delay(clock=4000000)
#fuses XT,NOWDT
#byte puerto_b=06   //Dirección del puerto B
#byte puerto_a=05   //Dirección del puerto A

void main()
{
   int entrada;
   set_tris_b(0x00);  //Configuro la puerta B como salida
   set_tris_a(0x1F);  //Configuro RA0, RA1, RA2, RA3 y RA4 como 
                      //entradas aunque por defecto ya están
                      //configuradas como entradas
                     
   puerto_b=0;      //inicializo todos los bits de la puerta B a cero

while(true) //bucle infinito
{
   entrada= puerto_a;//asigno a la variable entera entrada el valor
                     //actual del puerto A
   switch(entrada){
   
     case 0:
       puerto_b=0b0111111;
       break;
     case 1:
       puerto_b=0b00000110;
       break;
     case 2: 
       puerto_b=0b01011011;
       break;
     case 3: 
       puerto_b=0b01001111;
       break;
     case 4: 
       puerto_b=0b01100110;
       break;
     case 5: 
       puerto_b=0b01101101;
       break;
     case 6: 
        puerto_b=0b01111101;
       break;
     case 7: 
        puerto_b=0b00000111;
       break;   
   }   
}
}

Es muy parecido a la versión que tú has hecho y en cuando a optimización tampoco aporta nada, ya que ocupa de ROM 58 y de RAM 6, pero la he puesto ya que ofrece otra alternativa con respecto a la lectura de datos de los puertos, en vez de utilizar la función “input_a()” definida en CCS, utiliza la RAM para mapear la dirección del puerto como una variable más.

Conclusión: como código final optimizado el que tú has hecho, incluyendo #use fast_io(A) y quitando default.

Espero tú comentario sobre esto.

¿Se podría mejorar todavía? Yo creo que sí….

A ver si alguien más se anima.

Un saludo

[QuijotescoXp]

Hola Biblioman, agradezco las correcciones que has comentado.
Te pediré paciencia, porque es la primera vez que programo en C para PIC y aun me queda por descubrir todos los caminos que nos da CCS.
Es más, mirando tu revisión observo que no es necesario utilizar la función “input_a()”, ya que se puede saber el estado del puerto sólo con su identificador.
En cuanto al default del switch, lo hago por deformación profesional, y es que en la universidad me enseñaron que es buena práctica añadirlo aunque no haga falta, pero como bien comentas se puede quitar sin problemas.

Con todo lo hablado creo que se podría quedar así, a ver que opinas:

Código: Seleccionar todo

/******************************************************************************       
*                                                                             *
*  AUTOR      : QuijotescoXp                                                  *
*                                                                             *
*  EMAIL      : lrecueo1@alumno.uned.es                                       *
*                                                                             *
*  FECHA      : 26/09/09                                                      *
*                                                                             *
*  MICRO      : PIC 16F84A                                                    *
*                                                                             *
*  FUSES      : NOWDT                                                         *
*                                                                             *
*  OSC        :   XT                                                          *
*                                                                             *
*  LICENCIA   : GPL                                                           *
*                                                                             *
*  DESCRIPCIÓN: Decodificador de binario a decimal                            *
*                                                                             *
******************************************************************************/

#include <16F84A.h>
#use   delay( clock=4000000 )
#fuses XT, NOWDT
#byte  port_A = 0x05    // Dirección del port A.
#byte  port_B = 0x06    // Dirección del port B.

void main()
{
   set_tris_b( 0x00 );  // Se configura port B como salida.
   set_tris_a( 0x1F );  // Se configura port A como entrada
                     
   port_B = 0x00;       // Ningún segmento a ON
   
   while( true )
   {     
      switch( port_A )
      {
      case 0:
         port_B = 0x7E;
         break;
      case 1:
         port_B = 0x30;
         break;
      case 2:
         port_B = 0x57;
         break;
      case 3:
         port_B = 0x73;
         break;
      case 4:
         port_B = 0x39;
         break;
      case 5:
         port_B = 0x6B;
         break;
      case 6:
         port_B = 0x2F;
         break;
      case 7:
         port_B = 0x70;
         break;   
      }
   }
}

Bueno, no me enrrollo más y de verdad presiento que aquí vamos a aprender.

Saludos desde tierras del Quijote.

[biblioman]

Te pediré paciencia, porque es la primera vez que programo en C para PIC y aun me queda por descubrir todos los caminos que nos da CCS.

No te preocupes yo también estoy aprendiendo, por eso invito a la gente a que mejore mis ejemplos ó ponga los suyos propios, es la mejor forma de aprender.

Es más, mirando tu revisión observo que no es necesario utilizar la función “input_a()”, ya que se puede saber el estado del puerto sólo con su identificador.

Efectivamente una forma de acceder a los puertos es asignándoles un identificador a la dirección de memoria del puerto por medio de #byte identificador=direción de memoria del puerto. Por cierto, buena idea el poner el identificador directamente dentro de la sentencia switch, te has ahorrado una variable. Otra forma de acceder a los puertos es a través de punteros, espero llegar pronto a este tema en el tutorial. Realmente a mí, siempre que puedo me gusta evitar las funciones preparadas que trae CCS, son cómodas de usar, pero restan portabilidad si luego quieres usar el código para otros compiladores como SDCC.

En cuanto al default del switch, lo hago por deformación profesional, y es que en la universidad me enseñaron que es buena práctica añadirlo aunque no haga falta, pero como bien comentas se puede quitar sin problemas.

A mí también me enseñaron eso. La verdad es que el código es más legible y bonito si utilizas default. Pero si utilizas un PIC con pocos recursos la optimización del código puede ser una necesidad, es la desventaja de programar micros de gama baja-media en C y no en ensamblador.

Me gusta como ha quedado tú ejemplo. Espero que sigas participando en el foro y cualquier cosa que esté relacionada con la temática del sitio y quieras compartir será bien recibida.
Un saludo y hasta pronto.