Autor Tema: alternativas a output_a() (Leído 3047 veces)

ramirez · « **en:** 01 de Enero de 2010, 18:28:19 »

Hola a todos de nuevo, ante todo feliz año nuevo. Ahora expongo cual es mi duda, en estos momentos estoy utilizando un 16f874, por su gran número de entradas, utilizandolo de la siguiente manera:

El Puerto B entrada binaria para la unidad, aunque se que es suficiente con 4 dígitos, utilizaré 7,ya que esta señal vendrá de un 7 segmentos en un futuro.
El puerto C, idem de lo anterior para decenas. En ambos casos me sobra una entrada.
El puerto D, será utilizado en un futuro, por ello ahora no lo utilizo.

Ahora bien, entre el puerto A yE conectaré dos dispolay BCD, como se muestra en el esquema.Si solo utilizara las unidades, con el código que expongo a continuación no hay problema, pero ¿cómo puedo visualizar las decenas con la conexión de la figura?

Espero haber explicado bien la situación. Será bien agradecida cualquier sugerencia.

De nuevo gracias por vuestra colaboración.

CÓDIGO

#include <16f874.h> //pic a utilizar
#fuses XT,NOWDT //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz

///PROGRAMA

int unidad;
int decena;
int salida_unidad;
int salida_decena;
void main(void)

{

set_tris_a(0xff); //puerto A como salida
set_tris_b(0x00); //puerto B como entrada

do{

unidad=input_b();
decena=input_c();

switch (unidad){

case 0b00000000:
salida_unidad=0x0;
break;

case 0b00000001:
salida_unidad=0x1;
break;

case 0b00000010:
salida_unidad=0x2;
break;
case 0b00000011:
salida_unidad=0x3;
break;

case 0b00000100:
salida_unidad=0x4;
break;

case 0b00000101:
salida_unidad=0x5;
break;

case 0b00000110:
salida_unidad=0x6;
break;

case 0b00000111:
salida_unidad=0x07;
break;

case 0b00001000:
salida_unidad=0x8;
break;

case 0b00001001:
salida_unidad=0x9;
break;

}

switch (decena){

case 0b00000000:
salida_decena=0x0;
break;

case 0b00000001:
salida_decena=0x1;
break;

case 0b00000010:
salida_decena=0x2;
break;

case 0b00000011:
salida_decena=0x3;
break;

case 0b00000100:
salida_decena=0x4;
break;

case 0b00000101:
salida_decena=0x5;
break;

case 0b00000110:
salida_decena=0x6;
break;

case 0b00000111:
salida_decena=0x07;
break;

case 0b00001000:
salida_decena=0x8;
break;

case 0b00001001:
salida_decena=0x9;
break;

}

disable_interrupts(GLOBAL); //todas interrupciones desactivadas

output_a(salida_unidad);

/// AQUÍ NO SE QUE PONER PARA VISUALIZAR LAS DECENAS EN EL DISPLAY
}while(TRUE);
}

bigluis · « **Respuesta #1 en:** 02 de Enero de 2010, 02:50:29 »

No conosco mucho de CCS pero si de MikroC.

Código: C

void main(){
    TRISA=0;                       //Usamos todo el puerto a como salida
    TRISE=0;                       //Usamos todo el puerto E como salida
    TRISB=0XFF;                    //Usamos todo el puerto E como entrada
    TRISC=0XFF;                    //Usamos todo el puerto E como entrada
    while(1){                      //inicio del bucle infinito.
        PORTA=PORTC<<4 | PORTB;    //Movemos 4 espacios hacia la derecha los bits
                                   //del PORTC y aplicamos suma booleana con PORTB
                                   //para obtener los bits de entrada de PORTB
                                   //y los 2 ultimos bits del PORTC en los 2 bits superiores de PORTA.
        PORTE=PORTC >> 2;}}        //Movemos 2 espacios hacia la izquierda los bits
                                   //de PORTC para ubicar los bits 3 y 4 en los bits 0 y 1 de PORTE.

Lo que tienens que hacer con tu programa es mover los 4 espacios los bits de PORTC para asignar los 2 ultimos bits de PORTC a los 2 bits superiores de PORTA, y mover los bits 2 y 3 a los bits 0 y 1 de PORTE.

Otra opcion es utilizar

Código: C

PORTA.F4=PORTC.F0;
PORTA.F5=PORTC.F1;
PORTE.F0=PORTC.F2;
PORTE.F1=PORTC.F3;

Pero esta opcion ocupa mas lineas de codigo, no se si ocupa mas memoria deberias probar.

Exactamente no se como hacerlo en CCS pero sigue la misma logica.

Abajo adjunto los archivos, en donde esta el codigo fuente y el *.hex

Cryn · « **Respuesta #2 en:** 03 de Enero de 2010, 00:36:52 »

Para los diplays de los puertos A y E yo usaría el método de la "enmascaración" si es que no me equivoco de nombre y si corresponde al caso

Lo que haría es primero cargar el valor del primer display en una variable, posteriormente cargar el valor del otro display en otra variable, este último (suponiendo que es el display que esta compartido en A y E), desplazarlo cuatro lugares y hacer la enmascaración:

-la primera variable correspondiente al 1er display AND 0b00001111
-la segunda variable correspondiente al 2do AND 0b11110000
-Y después una OR entre ambas variables, con eso tendríamos el resultado de ambos display en una sola variable de 8bits. Los 2 primeros pasos no hacen falta si al momento de obtener el número que se mostrará en el display ya lo obtendríamos con los 0's al inicio o al final

Queda llevar los los últimos bits más significativos al puerto E, que de ser necesario con una AND sacamos lo que necesitamos del resultado de nuestra OR anterior => resultado AND 0b11000000 y con dos rotaciones a la izquierda tenemos los bits para el puerto E listo para mostrar.

El código ya va por tu cuenta, si te gusta la idea.

saludos.

ramirez · « **Respuesta #3 en:** 03 de Enero de 2010, 17:58:30 »

Hola de nuevo, primero dar las gracias por vuestras respuestas. He intentado hacer lo que has dicho, pero el código no funciona correctamente. Este compila correctamente y no da ningún error, os agradecería que le echarais un vistazo por si veis algún error. Yo seguiré intentando averiar que es lo que ocuure, sobre todo con la instrucción rotar que nunca la he utilizado.

De nuevo gracias por vuestra colaboración

CÓDIGO

#include <16f874.h> //pic a utilizar
#fuses XT,NOWDT //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz

///PROGRAMA

int unidad; /// VALOR DE ENTRADA DE UNIDAD
int decena; /// VALOR DE ENTRADA DE DECENA
int salida_unidad; /// VALOR DE SALIDA A VISUALIZAR EN DISPLAY_BCD
int salida_decena; /// VALOR DE SALIDA A VISUALIZAR EN DISPLAY_BCD
int display_unidad;
int display_decena;
int a=0;
int b=0;
int dos_porte;
int unidad_decena;

void main(void)

{

set_tris_a(0x00); //puerto A como salida
set_tris_b(0xff); //puerto B como entrada

set_tris_d(0x00); //puerto D como salida
set_tris_c(0xff); //puerto C como entrada

set_tris_e(0x00); //puerto E como entrada

do{

unidad=input_b();
decena=input_c();

switch (unidad){

case 0b00000000:
salida_unidad=0x0;
break;

case 0b00000001:
salida_unidad=0x1;
break;

case 0b00000010:
salida_unidad=0x2;
break;
case 0b00000011:
salida_unidad=0x3;
break;

case 0b00000100:
salida_unidad=0x4;
break;

case 0b00000101:
salida_unidad=0x5;
break;

case 0b00000110:
salida_unidad=0x6;
break;

case 0b00000111:
salida_unidad=0x07;
break;

case 0b00001000:
salida_unidad=0x8;
break;

case 0b00001001:
salida_unidad=0x9;
break;

}

switch (decena){

case 0b00000000:
salida_decena=0x0;
break;

case 0b00000001:
salida_decena=0x1;
break;

case 0b00000010:
salida_decena=0x2;
break;

case 0b00000011:
salida_decena=0x3;
break;

case 0b00000100:
salida_decena=0x4;
break;

case 0b00000101:
salida_decena=0x5;
break;

case 0b00000110:
salida_decena=0x6;
break;

case 0b00000111:
salida_decena=0x07;
break;

case 0b00001000:
salida_decena=0x8;
break;

case 0b00001001:
salida_decena=0x9;
break;

}

disable_interrupts(GLOBAL); //todas interrupciones desactivadas

for(a=0;a<3;a++){
rotate_left(&salida_decena,1);
}

salida_unidad=salida_unidad&=0b00001111;
salida_decena=salida_decena&=0b11110000;

unidad_decena=salida_unidad|=salida_decena; /// 8 bits de los dos display
dos_porte=unidad_decena&=0b11000000; /// Los 2 bits que debo de poner en el puerto E

for(b=0;b<1;b++){
rotate_left(&dos_porte,1);
}

output_a(unidad_decena);
output_e(dos_porte);

}while(TRUE);
}

Suky · « **Respuesta #4 en:** 03 de Enero de 2010, 19:16:11 »

Hola ramirez! Yo lo haría de la siguiente manera:

Código: C

output_a(( salida_unidad&0x0F)|((salida_decena&0x03)<<4));
output_e(salida_decena>>2);

Explicado sería: En los primeros 4 bits de PORTA (RA0-RA3) cargo los 4 bits menos significativos de salida_unidad, luego solo tomo los 2 bits menos significativos de salida_decena, los roto 4 posiciones a la izquierda para cargarlos en los pines RA4 y RA5. Y en el puerto E solo roto a la derecha 2 veces para colocar los bits 2 y 3 de salida_decena en los pines RE0 y RE1. Se entendió?

Nota: ten en cuenta que RA4 es a colector abierto.

Saludos!

bigluis · « **Respuesta #5 en:** 03 de Enero de 2010, 19:24:42 »

Supongo que la siguiente linea:

Cita de: Suky en 03 de Enero de 2010, 19:16:11

Código: C
output_a(( salida_unidad&0x0F)|((salida_decena&0x03)<<4));

Tambien se puede utilizar de la siguiente manenra:

Código: C

output_a( salida_unidad | (salida_decena<<4) );

Supongo que sera el mismo compilador el que se encargaria de producir las variables auxiliares para obtener los resultados, ademas ya que los bits 6 y 7 del PortA no estan implementados no importara si guardas algun valor en ellos o no, asi que, si en salida decena esta almacenado 0b00001111 y en salida unidad esta almacenado 0b00001010, en el registro PORTA se almacenara 0b1111 1010, pero como los bits 6 y 7 no estan implementados solo se almacenara 0b11 1010, que sera lo que se mostrara en la salida de PORTA.

A como esta hecho en el programa que esta arriba hecho en MikroC

Suky · « **Respuesta #6 en:** 03 de Enero de 2010, 19:45:16 »

Si es cierto

Como me gusta complicarla y hacer poco eficiente el código!

Saludos!

bigluis · « **Respuesta #7 en:** 03 de Enero de 2010, 20:03:03 »

Supongo que tampoco necesitas utilizar los switch, ya que aunque los utilices, las variables salida_unidad y salida_decena siempre seran iguales a las variables unidad y decena respectivamente, lo que quiero decir es que simplemente debes igualarlas sin necesidad de usar los switch.

Código: C

salida_unidad=unidad;
salida_decena=decena;

Es mas nisiquiera necesitas las variables auxiliares de salida con solo que hagas lo siguiente vastara.

Código: C

output_a( unidad | (decena<<4) );
output_e(decena>>2);

es decir el codigo deberia quedar asi:

Código: C

#include <16f874.h>            //pic a utilizar
#fuses XT,NOWDT   //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
 
///PROGRAMA
 
int unidad;             /// VALOR DE ENTRADA DE UNIDAD
int decena;             /// VALOR DE ENTRADA DE DECENA
 
void main(void)
 
{
 
set_tris_a(0x00);            //puerto A como salida
set_tris_b(0xff);            //puerto B como entrada
set_tris_d(0x00);            //puerto D como salida
set_tris_c(0xff);            //puerto C como entrada
set_tris_e(0x00);            //puerto E como entrada
 
 
do{
 
   unidad=input_b();
   decena=input_c();
   output_a( unidad | (decena<<4) );
   output_e(decena>>2);
   }while(TRUE);
}

La otra opcion es que utilices directamente las entradas pero no se si funcionaria en CCS, en MikroC si funciona, es decir:

Código: C

do{
   output_a( input_b() | (input_c()<<4) );
   output_e(input_c()>>2);
   }while(TRUE);

Suky · « **Respuesta #8 en:** 03 de Enero de 2010, 20:23:01 »

Lo que pasa que los switch seguramente después lo cambiará, porque leerá 7 bits y no 4.

Otra cosita, si trata los puertos de manera estándar no es necesario la configuración de los tris.

Saludos!

ramirez · « **Respuesta #9 en:** 04 de Enero de 2010, 07:54:54 »

Gracias a todos de nuevo por vuestra colaboración, funciona correctamente. Debo decir que las entradas es de 7 bits, ya que la señal viene de una salida 7 segmentos

TODOPIC

Autor Tema: alternativas a output_a() (Leído 3047 veces)

ramirez

alternativas a output_a()

bigluis

Re: alternativas a output_a()

Cryn

Re: alternativas a output_a()

ramirez

Re: alternativas a output_a()

Suky

Re: alternativas a output_a()

bigluis

Re: alternativas a output_a()

Suky

Re: alternativas a output_a()

bigluis

Re: alternativas a output_a()

Suky

Re: alternativas a output_a()

ramirez

Re: alternativas a output_a()