Contador BCD de 00 a 99 con arduino

Publicado el: 13 de abril de 2015
Principiante
Acerca de este proyecto
Cuenta desde 00 hasta 99 en forma ascendente o descendente utilizando un sòlo decodificador BCD (7447) y dos displays de 7 segmentos.
arduino contador multiplexacion
Publicidad
DETALLES

Este contador realizado en Arduino cuenta desde 00 hasta 99 en forma ascendente o descendente utilizando un sòlo decodificador BCD (7447) y dos displays de 7 segmentos, aprovechando la tècnica de multiplexaciòn.

La lista de componentes para la realizaciòn de este proyecto es la siguiente:

(1) Tarjeta Arduino One Rev 3.

(1) CI 74LS47. (Decodificador BCD).

(2) Displays de 7 segmentos de ànodo comùn.

(2) Transistores 2N3904 o equivalente.

(3) Push-buttons.

(7) Resistencias de 100Ω (limitadoras para los displays).

(3) Resistencias de 10kΩ (pull-up para los interruptores).

(2) Resistencias de 1KΩ (para los transistores)

Cables de conexiòn.

DIAGRAMA DEL CIRCUITO MONTADO EN PROTOBOARD



Se  utilizaràn 9 pines del arduino; 4 se destinaran para controlar al integrado decodificador BCD,  3 para los switches push-buttons y 2 para controlar los transistores.

Los pines4,5,6 y 7 del arduino controlaran las lìneas A,B,C,D del 7447.

Los pines 8,9 y 10 se configuraran como entradas, una para cada push-button respectivamente.

En el pin 8 se conectarà el switch para el conteo ascendente.

En el pin 9 se conectarà el switch para el conteo descendente.

En el pin 10 se conectarà el switch para resetear el contador.

Los pines 11y 12 actuaran com salidas para manejar cada transistor.

El circuito integrado decodificador utilizado es el 74LS47 que posee 16 pines. La figura muestra los pines utilizados:

Diagrama de pines del 7447



DIAGRAMA ESQUEMÁTICO


Del circuito se puede deducir que cuando se tiene un nivel lògico ALTO en la base de cada transistor, este entra en estado de conducciòn y conecta dinamicamente al positivo la lìnea de habilitaciòn de cada display correspondiente. Si ninguno de los transitores tiene un nivel lògico ALTO aplicado en sus bases, no se encenderà ningun segmento de los displays.

De esta manera, para visualizar el valor del conteo se siguen los siguientes pasos:

- Escribir el valor de las unidades en el decod BCD.

- Habilitar el transistor que controla el display de las unidades, mientras que se deshabilita el de las decenas.

- Escribir el valor de las decenas en el decod BCD.

- habilitar el transistor que controla el display de las decenas, mientras que se deshabilita el de las unidades.

Para poder visualizar simultaneamente los datos en los dos displays utilizando un sòlo decodificador BCD se hace uso de la tècnica del multiplexado, que consiste en conectar secuencialmente mientras se envìan los datos a visualizar, los datos correspondientes a cada dìgito. este proceso debe ser efectuado a una velocidad tal que engañe a la retina y parezca que se realiza simultaneamente en todos los displays.

El tiempo necesario para sostener el dato en cada display y producir esta sensaciòn varìa dependiendo, entre otros factores, del valor de las resistencias limitadoras, del nùmero de dìgitos que se tengan que mostrar y de las caracterìsticas propias del display. De esta manera es posible conectar màs displays y contar un mayor rango, por ejemplo hasta 999, o hasta 9999 usando un sòlo circuito decodificador BCD.

 

El primer display representarà la cuenta de las unidades y el otro el de las decenas. Los ànodos de los displays se conectan y desconectan de Vcc  mediante dos transistores NPN (Q1) y Q2) controlados por las lìneas 11 y 12 del arduino.



CODIFICACIÓN
Codigo arduino con antirebote-
Para funcionar con antirebote
//Programa contador BCD desde 00 hasta 99 con 1 ic 7447
const int A = 4;
const int B = 5;
const int C = 6;
const int D = 7;

const int arriba = 8;
const int abajo = 9;
const int reset = 10;

const  int displayUnidades = 11;
const  int displayDecenas = 12;

int estadoUp;
int estadoDown;
int estadoReset;

int estadoBotonAnteriorUp;
int estadoBotonAnteriorDown;
int estadoBotonAnteriorReset;

const int tiempo = 10;
const int tiempoAntirebote =10;

int numero = 35;
int unidades = 0;
int decenas = 0;

int conta = 0;  // Variable para el contador
boolean estadoAnterior = LOW;    // Estado anterior del botòn
boolean estadoActual = LOW; // Estado actual del botòn

byte inc;

void escribirBcd(byte num)
{
  digitalWrite(A, (num&1)==1);
  digitalWrite(B, (num&2)==2);
  digitalWrite(C, (num&4)==4);
  digitalWrite(D, (num&8)==8);
}

void setup() 
{
  pinMode(A,OUTPUT);
  pinMode(B,OUTPUT);
  pinMode(C,OUTPUT);
  pinMode(D,OUTPUT);
//  pinMode(displayUnidades,OUTPUT);
 // pinMode(displayDecenas,OUTPUT);
  
  pinMode(arriba,INPUT);
  pinMode(abajo,INPUT);
  pinMode(reset,INPUT);
  
//digitalWrite(displayUnidades,HIGH);
//digitalWrite(displayDecenas,HIGH);

  inc = 0;
 }
 
 //*******RUTINA ANTIREBOTE *********************************************************
boolean antiRebote  (int pin ) {
  int  contador =0;
  boolean estado;            // guarda el estado del boton 
  boolean estadoAnterior;    // guarda el ultimo estado del boton 

  do {
    estado = digitalRead (pin);
    if (estado != estadoAnterior ){  // comparamos el estado actual 
      contador = 0;
      estadoAnterior = estado;
    }
    else{
      contador = contador + 1;       // aumentamos el contador en 1
    }
    delay (1);
  }
  while (contador < tiempoAntirebote);
  return estado;
}

//************************************************************************

  
void habilitarUnidades()
{
  escribirBcd(unidades);
  digitalWrite(displayUnidades,HIGH);
  digitalWrite(displayDecenas,LOW);
  delay(tiempo);
}  

void habilitarDecenas()
{
  escribirBcd(decenas);
  digitalWrite(displayUnidades,LOW);
  digitalWrite(displayDecenas,HIGH);
  delay(tiempo);
}



void loop() 
{
 
 estadoUp = digitalRead(arriba);
 estadoDown = digitalRead(abajo);
 estadoReset = digitalRead(reset);
 //*********************************************************************************************
  if (estadoUp  != estadoBotonAnteriorUp) 
  {     //si hay cambio con respeto al estado 
    if (antiRebote (arriba))
    { //checamos  si esta presionado y si lo esta
      numero++;
    }
  }
  
  estadoBotonAnteriorUp = estadoUp;      // guardamos el estado del boton
  //*******************************************************************************************

 //*********************************************************************************************
  if (estadoDown  != estadoBotonAnteriorDown) 
  {     //si hay cambio con respeto al estado 
    if (antiRebote (abajo))
    { //checamos  si esta presionado y si lo esta
      numero--;
    }
  }
  
  estadoBotonAnteriorUp = estadoDown;      // guardamos el estado del boton
  //*******************************************************************************************

   //*********************************************************************************************
  if (estadoReset  != estadoBotonAnteriorReset) 
  {     //si hay cambio con respeto al estado 
    if (antiRebote (reset))
    { //checamos  si esta presionado y si lo esta
      numero=0;
    }
  }
  
  estadoBotonAnteriorReset = estadoReset;      // guardamos el estado del boton
  //*******************************************************************************************
  
  
//  estadoBotonAnteriorReset = estadoReset;      // guardamos el estado del boton
  

        if(numero>99)
        {
          numero = 0;
        }  
        if(numero<0)
        {
          numero = 99;
        }  
         
        decenas = numero/10;  //Extraigo el dìgito de las unidades
       
        unidades=  numero-( decenas*10);  //Extraigo el dìgito de las decenas
        
  
         habilitarUnidades();
         habilitarDecenas();
 
}

Codigo arduino sin antirebote-
Este codigo no hace uso del antirebote
const int A = 4;
const int B = 5;
const int C = 6;
const int D = 7;

const int arriba = 8;
const int abajo = 9;
const int reset = 10;

 const  int displayUnidades = 11;
const  int displayDecenas = 12;

int estadoUp;
int estadoDown;
int estadoReset;
const int tiempo = 10;

int numero = 0;
int unidades = 0;
int decenas = 0;
      
void escribirBcd(byte num)
{
  digitalWrite(A, (num&1)==1);
  digitalWrite(B, (num&2)==2);
  digitalWrite(C, (num&4)==4);
  digitalWrite(D, (num&8)==8);
}

void setup() 
{
  pinMode(A,OUTPUT);
  pinMode(B,OUTPUT);
  pinMode(C,OUTPUT);
  pinMode(D,OUTPUT);
  pinMode(displayUnidades,OUTPUT);
  pinMode(displayDecenas,OUTPUT);
  
  pinMode(arriba,INPUT);
  pinMode(abajo,INPUT);
  pinMode(reset,INPUT);
  
digitalWrite(displayUnidades,HIGH);
digitalWrite(displayDecenas,HIGH);


 }
 


  
void habilitarUnidades()
{
  escribirBcd(unidades);
  digitalWrite(displayUnidades,HIGH);
  digitalWrite(displayDecenas,LOW);
  delay(tiempo);
}  

void habilitarDecenas()
{
  escribirBcd(decenas);
  digitalWrite(displayUnidades,LOW);
  digitalWrite(displayDecenas,HIGH);
  delay(tiempo);
}  



void loop() 
{
 
 estadoUp = digitalRead(arriba);
 estadoDown = digitalRead(abajo);
 estadoReset = digitalRead(reset);
 
 
 
 if (estadoUp==HIGH)
 {
    delay(10);
    numero++;

 }
  

  if (estadoDown==HIGH)
 {
  delay(10);
   numero--;
 }  
 
  if (estadoReset==HIGH)
 {
    delay(10);
    numero=0;

   }




        if(numero>99)
        {
          numero = 0;
        }  
        if(numero<0)
        {
          numero = 99;
        }  
         
        decenas = numero/10;  //Extraigo el dìgito de las unidades
       
        unidades=  numero-( decenas*10);  //Extraigo el dìgito de las decenas
        
  
         habilitarUnidades();
         habilitarDecenas();
 
}

Autor: sistemasymicros
26 proyectos 6 seguidores 0 siguiendo

Ingeniero en electrónica. Maker, apasionado por la programación. Sigueme en sistemasymicros.

COMENTARIOS
Para publicar un comentario debes