En este post les voy a explicar paso a paso como hacer un contador ascendente de 0 a 99 manual y automático.
Materiales:
Diagrama de conexiones:
Los pines de conexión de los displays van puenteados: a con a , b con b, c con c , etc.
Contador con pulsador:
Al momento de presionar el pulsador, ira contando en forma ascendente desde el 0 al 99, cuando llegue a 99 el contador volverá a 0.A.
Explicación del código.
Primero declaramos los pines en donde irán conectados los pines de los displays.
int pines [] = {0, 1, 2, 3, 4, 5, 6};(g, f, e, d, c, b, a)
Definimos tr1 (pin donde ira conectada la base del transistor1), tr2 (pin donde ira conectada la base del transistor2) y pulsador(pin donde ira conectado el pulsador en configuración pull-down).
#define tr1 8 #define tr2 10 #define pulsador A0
Agregamos las siguientes variables:
- estadop: la vamos a utilizar para realizar un antirrebote.
- n1: almacenara la posicion del array para mostrar la unidad.
- n2: almacenara la posicion del array para mostrar la decena.
- pausa: variable de pausa ente activación de los displays para la multiplexación.
bool estadoP = 0; byte n1 = 0; byte n2 = 0; short pausa = 50;
Definimos un array en el cual almacenaremos los valores de los números en código binario con orden ascendente de 0 a 9, este array lo ocupamos si estamos utilizando displays de ánodo común
byte numerosAnodo[] {
B0000001,//0
B1001111,//1
B0010010,//2
B0000110,//3
B1001100,//4
B0100100,//5
B0100000,//6
B0001111,//7
B0000000,//8
B0000100,//9
};
Este array lo ocupamos si estamos utilizando displays de cátodo común.
byte numerosCatodo[] {
B1111110,//0
B0110000,//1
B1101101,//2
B1111001,//3
B0110011,//4
B1011011,//5
B1011111,//6
B1110000,//7
B1111111,//8
B1111011,//9
};
En el void setup declaramos entradas y salidas.
void setup() {
pinMode(tr1, OUTPUT);
pinMode(tr2, OUTPUT);
pinMode(pulsador, INPUT);
Creamos este ciclo for para declarar los pines que van conectados a los displays (como van en orden, de 0 a 6 lo podemos hacer de esta forma)
for (int led = 0; led < 8; led++) {
pinMode(pines[led], OUTPUT);
}
}
void loop() {
bool pul = digitalRead(pulsador);
Cada vez que presionamos el pulsador, la variable n1 (variable que lleva el valor del numero que aparecerá en el display de la unidad) se suma. Si n1 = 10; n1 = 0 y n2 (lleva el valor del numero que aparecerá ;en el display de la decena) se suma. Cuando n2 = 10 entonces n2 = 0.
if (pul != estadoP) {
if (pul == HIGH) {
n1++;
if (n1 == 10 ) {
n1 = 0;
n2++;
}
if (n2 == 10){
n2 = 0;
}
}
}
estadoP = pul;
La multiplexación nos permite visualizar los dos números a la vez conectando los displays a los mismos pines. Esto lo logramos apagando un display y prendiendo el otro. El control de la activación de los displays lo hacemos con los transistores.
Primero, activamos el display de las decenas, desactivamos el display de las unidades y mostramos el valor de la variable con la condición, PORTD = numerosAnodo[n2];. PORTD nos permite mostrar los datos en el display mediante los números binarios que declaramos anteriormente en el array. Establecemos una pausa,
digitalWrite(tr1, HIGH); digitalWrite(tr2, LOW); PORTD = numerosAnodo[n2]; delay(pausa);
Activamos el display de las unidades, desactivamos el display de las decenas y mostramos el valor de la variable con la condición, PORTD = numerosAnodo[n1];.
Establecemos una pausa,
digitalWrite(tr2, HIGH); PORTD = numerosAnodo[n1]; delay(pausa); }QUE ES UN ARRAY (MATRIZ) Y COMO UTILIZARLO EN LA PROGRAMACION DE ARDUINO
Código completo del contador con pulsador.
int pines [] = {0, 1, 2, 3, 4, 5, 6};
#define tr1 8
#define tr2 10
#define pulsador A0
bool estadoP = 0;
byte n1 = 0;
byte n2 = 0;
short pausa = 50;
byte numerosAnodo[] {
B0000001,//0
B1001111,//1
B0010010,//2
B0000110,//3
B1001100,//4
B0100100,//5
B0100000,//6
B0001111,//7
B0000000,//8
B0000100,//9
};
byte numerosCatodo[] {
B1111110,//0
B0110000,//1
B1101101,//2
B1111001,//3
B0110011,//4
B1011011,//5
B1011111,//6
B1110000,//7
B1111111,//8
B1111011,//9
};
void setup() {
pinMode(tr1, OUTPUT);
pinMode(tr2, OUTPUT);
pinMode(pulsador, INPUT);
for (int led = 0; led < 8; led++) {
pinMode(pines[led], OUTPUT);
}
}
void loop() {
bool pul = digitalRead(pulsador);
if (pul != estadoP) {
if (pul == HIGH) {
n1++;
if (n1 == 10 ) {
n1 = 0;
n2++;
}
if (n2 == 10){
n2 = 0;
}
}
}
estadoP = pul;
digitalWrite(tr1, HIGH);
digitalWrite(tr2, LOW);
PORTD = numerosAnodo[n2];
delay(pausa);
digitalWrite(tr1, LOW);
digitalWrite(tr2, HIGH);
PORTD = numerosAnodo[n1];
delay(pausa);
}
Contador sin pulsador:
Este contador empezara a contar automáticamente cuando energicemos la placa de arduino.
Explicación del código.
Primero declaramos los pines en donde irán conectados los pines los displays.
int pines [] = {0, 1, 2, 3, 4, 5, 6};
(g, f, e, d, c, b, a)
Definimos tr1 (pin donde ira conectada la base del transistor1) y tr2 (pin donde ira conectada la base del transistor2).
#define tr1 8 #define tr2 10
Agregamos las siguientes variables:
- n1: almacenara la posicion del array para mostrar la unidad.
- n2: almacenara la posicion del array para mostrar la decena.
- pausa: variable de pausa ente activación de los displays para la multiplexasion.
- velocidad: controlamos la velocidad del contador.
byte n1 = 0; byte n2 = 0; short pausa = 50;
short velocidad= 50;
Definimos un array en el cual almacenaremos los valores de los números en código binario con orden ascendente de 0 a 9, este array lo ocupamos si estamos utilizando displays de ánodo común.
byte numerosAnodo[] {
B0000001,//0
B1001111,//1
B0010010,//2
B0000110,//3
B1001100,//4
B0100100,//5
B0100000,//6
B0001111,//7
B0000000,//8
B0000100,//9
};
Este array lo ocupamos si estamos utilizando displays de cátodo común.
byte numerosCatodo[] {
B1111110,//0
B0110000,//1
B1101101,//2
B1111001,//3
B0110011,//4
B1011011,//5
B1011111,//6
B1110000,//7
B1111111,//8
B1111011,//9
};
En el void setup declaramos entradas y salidas
void setup() {
pinMode(tr1, OUTPUT); pinMode(tr2, OUTPUT);
Creamos este ciclo for para declarar los pines que van conectados a los displays (como van en orden, de 0 a 6 lo podemos hacer de esta forma)
for (int led = 0; led < 8; led++) {
pinMode(pines[led], OUTPUT);
}
}
void loop() {
La variable n1 (variable que lleva el valor del numero que aparecerá en el display de la unidad) se suma. Si n1 = 10 entonces n1 = 0, n2 (lleva el valor del numero que aparecerá en el display de la decena) se suma. Cuando n2 = 10 entonces n2 = 0.
n1++;
if (n1 == 10 ) {
espacio = 0;
i++;
}
if ( n2 == 10){
n2 = 0;
}
Iniciamos un ciclo for, este nos ayudara a controlar la velocidad del contador
for (int z = 0; z < velocidad; z++ ){
La siguiente parte es igual a la del contador con pulsador:
digitalWrite(tr1, HIGH); digitalWrite(tr2, LOW); PORTD = numerosAnodo[n2]; delay(pausa); digitalWrite(tr1, LOW); digitalWrite(tr2, HIGH); PORTD = numerosAnodo[n1]; delay(pausa); } }
Código completo del contador sin pulsador.
int pines [] = {0, 1, 2, 3, 4, 5, 6};
#define tr1 8
#define tr2 10
byte n1 = 0;
byte n2 = 0;
short pausa = 50;
short velocidad = 2;
byte numerosAnodo[] {
B0000001,//0
B1001111,//1
B0010010,//2
B0000110,//3
B1001100,//4
B0100100,//5
B0100000,//6
B0001111,//7
B0000000,//8
B0000100,//9
};
byte numerosCatodo[] {
B1111110,//0
B0110000,//1
B1101101,//2
B1111001,//3
B0110011,//4
B1011011,//5
B1011111,//6
B1110000,//7
B1111111,//8
B1111011,//9
};
void setup() {
pinMode(tr1, OUTPUT);
pinMode(tr2, OUTPUT);
for (int led = 0; led < 8; led++) {
pinMode(pines[led], OUTPUT);
}
}
void loop() {
n1++;
if (n1 == 10 ) {
n1 = 0;
n2++;
}
if ( n2 == 10){
n2 = 0;
}
for (int z = 0; z < velocidad; z++ ){
digitalWrite(tr1, HIGH);
digitalWrite(tr2, LOW);
PORTD = numerosAnodo[n2];
delay(pausa);
digitalWrite(tr1, LOW);
digitalWrite(tr2, HIGH);
PORTD = numerosAnodo[n1];
delay(pausa);
}
}
Publicar un comentario