Construyendo un contador binario

con Arduino
Del poco tiempo que tengo ultimamente para hacer cosillas,
el Viernes por fin pude ir a la tienda de electrónica para
comprar materiales :).

Básicamente compre una placa de prototipos, unos leds con

resistencias y un LDR ( Resistencia variable según la luz ).
De momento dejaremos el LDR para otra entrada y
centremonos en las bombillas.
La conexión del circuito es bastante sencilla, simplemente
enchufamos la salida digital del arduino al lado positivo del
LED poniendo entre medias una resistencia, mientras que el
lado negativo de cada LED iría al la conexión de tierra de la
placa Arduino.

Como veis en el esquema, nada complicado

Montandolo en la placa de prototipos, a mi me ha quedado

algo así:

Una vez tenemos el circuito montado, viene la parte de la

programación, antes de nada hay que descargarse el genial
entorno de programación de la gente de Arduino. Os lo
podeis descargar desde aquí.

El código en cuestión sería algo como:

1
2
3 int outPin[] = {13, 12, 11, 10, 9};
4
int delayValue = 600;
5
6
void setup()
7 {
8 int i = 0;
9 for ( i = 0; i < 5; i++)
10 pinMode(outPin[i], OUTPUT);
}
11
12 void loop()
13 {
14
15 int i = 0, j=0;
16
17 for ( i = 0; i < 32; i++)
18 {
for ( j = 0; j < 5; j++)
19 {
20 if ( ( (i >> j) & 1 ) == 1 )
21 digitalWrite(outPin[j], HIGH);
22 else digitalWrite(outPin[j], LOW);
}
23 delay(delayValue);
24 }
25 }
26
27

Como veis es bastante sencillo, declaramos un array con el

conjunto de pines a los cuales estan enganchados nuestros
LEDs. En la función setup, los configuramos en modo salida.

La chicha esta en la función loop(), esta se ejecutará una y

otra vez, lo que hacemos es iterar por los 32 numeros que
podemos mostrar, ya que tenemos 5 LEDs, y 2 elevado a 5
son 32. Por cada número, encedemos o apagamos cada led
correspondiente. La clave esta en el bucle que realiza la
operación “(i >> j) & 1”. Cada iteración del bucle divide el
 numero en cuestion por 2 y se queda unicamente con el bit
de menor valor. Asi sabemos si tenemos que encender o no
el LED.

Por ejemplo, para mostrar el número 21, que en binario es

(10101) deberiamos encender los LEDs 0, 2 y 4 y dejar
apagados el resto. El calculo sería:

 LED 0: 21 (10101 & 1) -> 1 , encendido

 LED 1: 21 / 2 = 10 (01010 & 1) -> 0, apagado
 LED 2: 21 / 4 = 5 (00101 & 1) -> 1, encendido
 LED 3: 21 / 8 = 2 (00010 & 1) -> 0, apagado
 LED 4: 21 / 16 = 1 (00001 & 1) -> 1, encendido

Como vemos, el resultado del calculo es correcto.

Básicamente lo que se hace es ir desplazando los bits hacia
la derecha y quedandonos con el bit menos significativo.

Bueno, pues dada la maravillosa sencillez que caracteriza al

Arduino, solo nos queda darle al boton de Upload, y
veremos, como las lucecitas empiezan a encenderse.

Os dejo un video de mi resultado

Práctica 10 Encender un LED con botón

pulsador y luego apagarlo con el mismo
botón
Posted on 13 Febrero, 2017 by Editor
10.1 Objetivo General:
Encender un LED utilizando un botón pulsador, luego apagar el LED
utilizando el mismo botón pulsador.

Nueva práctica sobre encender una serie de LEDs tipo estrella fugaz,
ver Práctica 13.

10.2 Materiales y Métodos:

1. Un LED.
2. Una tarjeta Arduino Uno-R3 o Arduino Mega 2560.
3. Un cable USB impresora.
4. Un computador.
5. Cables para el montaje del circuito.
6. Tarjeta Protoboard.
7. Una Resistencia Eléctrica de 220 ohm.
8. Un Botón Pulsador.

En la práctica 2 el LED se encendía al presionar el botón, pero si se

soltaba el botón el LED se apagaba. En esta práctica se quiere utilizar el
botón para que encienda el LED y este se quede encendido a pesar de
que se deje de presionar el botón. Luego si se quiere apagar el LED, el
código debe dar la posibilidad de al oprimir el mismo botón, el LED se
apague. Note que el circuito es el mismo que el de la práctica 2. El
código de esta práctica puede ser utilizado en general para inicializar
código a ejecutar por Arduino. Por ejemplo, si se diseña un robot móvil
seguidor de línea, el código puede ser empleado para activar el
funcionamiento del robot.

10.3 Montaje de la práctica:

Antes de comenzar la realización del montaje del circuito electrónico, se
debe realizar el circuito en el programa Fritzing. Se debe tener en cuenta
el conocimiento de cuál es el cátodo y ánodo del LED. Se coloca el
ánodo en el pin 13 y el cátodo a tierra (ground), usar el pin 5V y conectar
al botón como se muestra en la figura 2:
 Figura 2. Montaje del circuito en el programa Fritzing
Se observa en la Figura 2 que se está utilizando el Arduino Uno, si se
utiliza la tarjeta Arduino Uno-R3 el mismo procedimiento. Como se
observa en la Figura 2, el Protoboard nos ayuda a insertar el LED e
instalar el circuito a través de cables, al igual que la resistencia eléctrica y
el botón pulsador. La línea que esta de color rojo que conecta el LED a la
tarjeta Arduino emite los 5V al estar conectado la tarjeta al computador
(El computador es capaz de proveerle Arduino 5V). Los 5V como se
observa van hacia al botón y luego al cerrarse el circuito le deja pasar al
pin 7. Para proteger el circuito y evitar que al pin 7 no le llegue más de
5V, le colocamos al circuito una resistencia eléctrica, la cual llevara en
gran parte de esa señal a tierra.

Luego que tengamos armado el circuito en el programa Fritzing, se

comienza con el desarrollo del programa en el IDE de Arduino.

10.3 IDE de Arduino para la práctica:

– Se selecciona la tarjeta Arduino que se esta utilizando sea Arduino
Uno-R3 o Arduino Mega 2560.

– Se selecciona el Puerto Serial. Bajo que puerto USB se va a conectar

el Arduino con el computador.

– Se empieza a realizar el código:

 Inicialmente debemos darle un nombre de qué consiste el codigo,

esto se hace a través del símbolo //, se puede colocar el título de la
 práctica o del programa en sí. También se puede utilizar como
comentarios dentro del programa.
 Se declaran las variables. En la práctica se declaran de tipo
constante, una variable que no cambiara durante el desarrollo del
programa, su comando es const, además se debe especificar qué
tipo de datos se almacenará en la constante, en este caso será
entero y su comando es int, luego se le da el nombre de la variable;
en la tarjeta Arduino se coloca el ánodo en el pin 13, la variable se
le asignara el valor de 13. También se declara la variable botón en
el pin 7 y una variable entero val igual a cero (0), la diferencia de
las demás variables es que la variable val no será constante va a
variar entre 0 y 1, en función de si el botón está presionado o no.
 Se define si la variable declarada son de tipo entrada o de salida,
para eso se utiliza el comando void setup(), se abre corchete ({)
para saber qué es lo que contiene ese comando y al finalizar el
comando se cierra corchete (}). Internamente del corchete se
declara que la variable LED es de salida, esto se realiza a través
del comando pinMode, este a su vez necesita como argumento la
variable y el tipo de señal de la misma, es
decir pinMode(LED,OUTPUT); en la que OUTPUT indica que la
señal saldrá del pin 13 permitiendo encender el LED. Para definir el
botón pulsador lo importante es definir el pin donde está conectado
el boton (pin 7), este se define en la programación en vez de ser
un OUTPUT es un INTPUT, cada vez que el reciba en
ese INPUT él va a tomar una acción; la cual es decirle Arduino que
tome una señal digital en el pin 13 y encienda el LED, su comando
será pinMode(BONTON,INPUT).
 Luego de definir las variables, se procede a realizar la estructura
del código a través del comando voidloop (), de igual manera se
abre corchete({) y se cierra (}) luego de terminar su cumplimiento.
Internamente del corchete se establecen las instrucciones que
ejecutara Arduino continuamente. Se utilizara la variable val la cual
leerá digitalmente lo que sucede en el pin 7 (botón), su comando
seria digitalRead(BOTON). La práctica permite introducir otra
estructura de programación la cual es if, la que significa si en
español. La estructura if es un condicional que permite decidir en
función del valor de la variable val, si este es alto (HIGH=1) o si es
bajo (LOW=0). Se utiliza una variable estado (state) que registrará
los cambios de HIGH y LOW cuando se pulsa el botón de esta
manera se crea un suiche de encendido que luego al volver a
 presionar sirve para apagar lo que esté dentro del if que contenga
la variable state.
 Para que el LED se encienda, si state==1 se utiliza el
comando digitalWrite(LED,HIGH). Para quel LED pueda apagarse
se utiliza el mismo comando digitalWrite pero indicándole esta vez
una señal baja LOW, esto cuando el state esté en 0.
 Al terminar el desarrollo del programa se debe compilar para
verificar si existen errores dentro del codificado. Luego si no
existen errores se debe cargar el código en la tarjeta Arduino para
que lo ejecute.

NOTA: Para quel IDE de Arduino pueda entender los comandos es

necesario que al final de cada instrucción se coloque punto y coma (;).

En la siguiente imagen se mostrara como quedo plasmado en el IDE de

Arduino, los procedimientos anteriormente señalados:
// Práctica encender LED con botón pulsador y luego apagar LED con el mismo
//boton pulsador
const int LED =13;
const int BOTON = 7;
int val = 0; //val se emplea para almacenar el estado del boton
int state = 0; // 0 LED apagado, mientras que 1 encendido
int old_val = 0; // almacena el antiguo valor de val
void setup(){ // definir si la variable es de entrada // o salida.
pinMode(LED,OUTPUT); // establecer que el pin digital es una señal de salida
pinMode(BOTON,INPUT); // y BOTON como señal de entrada
}
void loop() { // loop = realice un lazo continuamente
val= digitalRead(BOTON); // lee el estado del Boton
if ((val == HIGH) && (old_val == LOW)){
state=1-state;
delay(10);
}
old_val = val; // valor del antiguo estado
if (state==1){
digitalWrite(LED, HIGH); // enciende el LED
}
else{
digitalWrite(LED,LOW); // apagar el LED
}
}
Algoritmo 1 Código para encender y apagar un LED utilizando un
botón pulsador.

Implementación del algoritmo 1 en el simulador https//123d.circuits.io:

https://circuits.io/circuits/3991652-practica-10-encender-un-led-con-
boton-pulsador-y-luego-apagarlo-con-el-mismo-boton

Práctica 13 Encender una secuencia de

varios LEDs (Estrella fugaz)
Posted on 5 Enero, 2018 by Editor

13.1 Objetivo General:

Encender una secuencia de varios LEDs simulando una estrella fugaz.

Un conjunto de 12 LEDs serán encendidos de forma secuencial. Se

simula con este práctica el comportamiento de una estrella fugaz.

13.2 Materiales y Métodos:

1. 12 LEDs (Colores: Amarillo, Verde y Rojo).
2. Una tarjeta Arduino Uno-R3 o Arduino Mega 2560.
3. Un cable USB impresora.
4. Un computador.
5. Cables para el montaje del circuito.
6. Tarjeta Protoboard.
7. 12 Resistencias Eléctrica de 220 ohm.

13.3 Montaje de la práctica:

Antes de comenzar la realización del montaje del circuito electrónico, se
debe realizar el circuito en el programa TinkerCad. Cada LED será
conectado tal como lo hicimos en la Práctica 1 donde encendimos y
apagamos un LED, o como en la Práctica 11 donde encendimos una
secuencia de LEDs simulando un semáforo. Se van a usar los pines del
2 al 13 para conectar cada uno de los 12 LEDs, ver Figura 2:
 Figura 2. Montaje del circuito en el programa TinkerCAD

Se observa en la Figura 2 que se está utilizando el Arduino Uno, si se

utiliza la tarjeta Arduino Uno-R3 el mismo procedimiento. Como se
observa en la Figura 2, el Protoboard nos ayuda a instalar los LEDs e
instalar el circuito a través de cables, al igual que las resistencias.

Luego que se tiene armado el circuito en el programa TinkerCad, se

comienza con el desarrollo del programa en el IDE de Arduino.

13.4 IDE de Arduino para la práctica:

– Se selecciona la tarjeta Arduino que se esta utilizando sea Arduino
Uno-R3 o Arduino Mega 2560.

– Se selecciona el Puerto Serial. Bajo que puerto USB se va a conectar

el Arduino con el computador.

– Se empieza a realizar el código:

 Inicialmente debemos darle un nombre de qué consiste el código,

esto se hace a través del símbolo //, se puede colocar el título de la
práctica o del programa en sí. También se puede utilizar como
comentarios dentro del programa.
 Se declaran las variables. En esta práctica introduciremos un tipo
de variable que no ha sido utilizada en las prácticas anteriores y es
los vectores o arreglos. En concreto se crea un vector del tipo
entero intpinArray[ ]={2,3,….}. Los corchetas indican que se esta
declarando un vector. Para seleccionar una entrada específica del
 vector se usa pinArray[1] y dará como resultado 3. Los vectores en
el arduino IDE van desde 0 hasta n.
 Se declaran variables del tipo entero que definen el tiempo entre
encender una luz y otra (waitStart), el número de LEDs que se
encienden simultáneamente (tailLength) y el número de LEDs
(lineSize). Las tres variables son del tipo int.
 En el segmento de void setup se declara que cada componente del
vector pinArray es del tipo OUTPUT . Esto se hace de forma
compacta utilizando un lazo for que va desde 0 hasta que i sea
menor ( lt ) al número de LEDs.
 En el segmento de void setup se indica que enciendan la cantidad
de LEDs indicada en tailLength, luego mediante una
instrucción if se establece que a partir del LED tailLength encienda
el siguiente pero apague el último de la cola. Así sucesivamente
hasta llegar al final del número de LEDs
 Al terminar el desarrollo del programa se debe compilar para
verificar si existen errores dentro del codificado. Luego si no
existen errores se debe cargar el código en la tarjeta Arduino para
que lo ejecute.

NOTA: Para quel IDE de Arduino pueda entender los comandos es

necesario que al final de cada instrucción se coloque punto y coma (;).

En la siguiente imagen se mostrara como quedo plasmado en el IDE de

Arduino, los procedimientos anteriormente señalados: <\p>

2 //Estrella fugaz
3 int pinArray [] = {2,3,4,5,6,7,8,9,10,11,12,13 }; // Vector donde se van a declarar
4 int waitStart= 200; // Tiempo entre encender un LED y otro
5 int tailLength = 4; // Numero de LEDs activos
6 int lineSize = 12; // Numero total de LEDs
7
8 void setup()
9 {
10 int i;
11 for (i=0; i&lt; lineSize; i++)
12 {
13 pinMode(pinArray[i], OUTPUT);
14 }
15 }
16
17 void loop()
18 {
19 int i;
20 int tailCounter = tailLength; // Se establece un contador con los LEDS
21 //que deben encenderse al mismo tiempoI set up the
22 length in a counter
 23 for (i=0; i&lt;lineSize; i++)
24 {
25 digitalWrite(pinArray[i],HIGH); // Se enciende tailLength LEDs de forma consecut
26 delay(waitStart); // Controla la rapidez de encendido de cada LED
27 if (tailCounter == 0)
28 {
29 digitalWrite(pinArray[i-tailLength],LOW); // Apaga los LEDs de la cola hacia a
30 }
31 else
32 if (tailCounter &gt; 0)
33 tailCounter--;
34 }
35 for (i=(lineSize-tailLength); i&lt;lineSize; i++)
36 {
37 digitalWrite(pinArray[i],LOW); // Apague los LEDs restantes
38 delay(waitStart); // Controla la rapidez con que se apagan los LEDs
39 }
}
Algoritmo 1 Código para encender y apagar un LED utilizando un
botón pulsador.

Implementación del algoritmo 1 en el simulador TinkerCad:

https://www.tinkercad.com/things/076jCBQwb8B-practica-13-encender-
una-secuencia-de-varios-leds

13.5 Conclusión:
En esta práctica se ha mostrado como encender una secuencia de LEDs
utilizando la tarjeta Arduino. Hemos avanzado en programación al
introducir el manejo de variables del tipo Array o vectores. El código
permite aumentar o disminuir el tiempo en el que encienden los LEDs y a
su vez definir cuantos LEDs van a estar encendidos (tiempo y cola de la
estrella fugaz)

Numeros binarios
Practica 6
Materiales:

1. 4 Leds
2. 4 Resistencias
Objetivo:
Con los 4 leds representar los números del 1 al 15 en binario, es decir, empezando del 0001 hasta el
1111, cada led representara una posición de un espacio del numero binario empezando de izquierda a
derecha, por medio del Monitor serial se ingresara un numero en decimal entre el 1 y el 15, el cual el
programa leerá y prenderá los leds en representación de su forma binaria.

Diagrama:
Código:

int Numero = 0; //variable donde se guardara el numero que se escriba

void setup() {
Serial.begin(9600);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
}

//Metodo para prender los leds segun su numero

void PrenderLeds(boolean a, boolean b, boolean c, boolean d){
digitalWrite(5,a); //5, 6, 7 y 8 son los pines que se utilizaran pueden
variar
digitalWrite(6,b); //a, b, c y d sirven para indicar si el valor sera
HIGH o LOW
digitalWrite(7,c);
digitalWrite(8,d);
}
void loop() {
if (Serial.available() > 0) { //Si se detecta algun pulso entrara a la
condicion
Numero = Serial.parseInt(); //Convierte en numero lo que se ingrese
desde el monitor serial
if (Numero == 1){ //Si es 1 realizara los siguientes pasos donde
aplicaran para todos los numeros
Serial.println("Numero uno 1000"); //Se despliega el mensaje
PrenderLeds(1,0,0,0); //Se manda un 1 en la posicion del led a
prender y un 0 para apagarlo
}
if (Numero == 2){
Serial.println("Numero dos 0100");
PrenderLeds(0,1,0,0);
}
if (Numero == 3){
 Serial.println("Numero tres 1100");
PrenderLeds(1,1,0,0);
}
if (Numero == 4){
Serial.println("Numero cuatro 0010");
PrenderLeds(0,0,1,0);
}
if (Numero == 5){
Serial.println("Numero cinco 1010");
PrenderLeds(1,0,1,0);
}
if (Numero == 6){
Serial.println("Numero seis 0110");
PrenderLeds(0,1,1,0);
}
if (Numero == 7){
Serial.println("Numero siete 1110");
PrenderLeds(1,1,1,0);
}
if (Numero == 8){
Serial.println("Numero ocho 0001");
PrenderLeds(0,0,0,1);
}
if (Numero == 9){
Serial.println("Numero nueve 1001");
PrenderLeds(1,0,0,1);
}
if (Numero == 10){
Serial.println("Numero diez 0101");
PrenderLeds(0,1,0,1);
}
if (Numero == 11){
Serial.println("Numero once 1101");
PrenderLeds(1,1,0,1);
}
if (Numero == 12){
Serial.println("Numero doce 0011");
PrenderLeds(0,0,1,1);
}
if (Numero == 13){
Serial.println("Numero trece 1011");
PrenderLeds(1,0,1,1);
}
if (Numero == 14){
Serial.println("Numero catorce 0111");
PrenderLeds(0,1,1,1);
}
if (Numero == 15){
Serial.println("Numero quince 1111");
PrenderLeds(1,1,1,1);
}
if (Numero > 15){
Serial.println("Numero fuera de rango");
PrenderLeds(0,0,0,0);
}
}
}
Vídeo:
Para abrir el Monitor serial basta con la combinacion de teclas Ctrl + Shift + M o directo desde el IDE
de arduino en la opcion de Herramientas>Monitor serial
/* Contador númerico ascendente y descendente con 2 botones
uno para incrementar y el otro para decrementar */

const int PinContador = 9; // boton de Incr conectado al pin 10

const int PinUpDown = 10; // boton de Decr conectado al pin 9

const int tiempoAntirebote = 10;

int cuenta = 0; // lleva la cuenta de las veces que presionamos
el botón
byte BtnContador;
byte BtnContadorAnt;
byte BtnUpDown;
byte BtnUpDownAnt;
byte UpDown = true; // UpDown = true incrementa Updown = false
decremetna

const byte pin[] = {2,3,4,5,6,7,8};

// 0 1 2 3 4
const byte segmento[] = {0b1111110, 0b0110000, 0b1111001, 0b1111001, 0b0110011,
// 5 6 7 8 9
0b1011011, 0b1011111, 0b1110000, 0b1111111, 0b1111011};

//Función antirebote botón inicio

boolean antirebote(byte pin) {
int contador = 0;
boolean estado; // guarda el estado del botón
boolean estadoAnt; // guarda el último estado del botón

do {
estado = digitalRead(pin); // Leer el estado del botón y guardarla en la
variable "estado"
if(estado != estadoAnt) { // comparamos el estado actual del botón con el Ant
contador = 0; // si es diferente contador va a valer 0 y
reiciamos el contador, "!=" significa diferente a
estadoAnt = estado; // guardamos el valor de "estado" que leimos en
"estadoAnt"
}
else {
contador = contador + 1; // en caso de que sea igual "contador" sumará 1
}
delay(1);
} while(contador < tiempoAntirebote);

return estado;
}

// Función antirebote botón fin

void actualizarNumero() {
for (int i=0; i<7; i++){
digitalWrite(pin[i], segmento[cuenta]);
}
}

void setup() {

// declaramos los LEDS como salidas

for (int i=0; i<7; i++){
pinMode(pin[i], OUTPUT);
}

pinMode(PinContador, INPUT); // declaramos los botones como entradas

pinMode(PinUpDown, INPUT);
}

void loop() {

// codigo botón Incr inicio

BtnContador = digitalRead(PinContador); // leemos el estado del botón

if(BtnContador != BtnContadorAnt) { // si hay cambio con respecto al estado Ant
if (antirebote(PinContador)) { // checamos si está presionado y si lo está,
if (UpDown) { // cambia de UP a Down con cada pulsada
cuenta++;
if (cuenta > 9) {
cuenta = 9;
}
} else {
cuenta--;
if (cuenta < 0) {
cuenta = 0;
}
}
}
}

BtnContadorAnt = BtnContador; // guardamos el estado del botón

BtnUpDown = digitalRead(PinUpDown); // leemos el estado del botón

if(BtnUpDown != BtnUpDownAnt) { // si hay cambio con respecto al estado Ant
if (antirebote(PinUpDown)) { // checamos si está presionado y si lo está,
UpDown = !UpDown; //
disminuimos la cuenta en 1
}
}
BtnUpDownAnt = BtnUpDown; // guardamos el estado del botón

actualizarNumero(); // desplegamos la cuenta en el display

}
 // codigo botón Decr fin

Cambios:

1. Agregué esto

const byte pin[] = {2,3,4,5,6,7,8};

// 0 1 2 3 4
const byte segmento[] = {0b1111110, 0b0110000, 0b1111001, 0b1111001, 0b0110011,
// 5 6 7 8 9
0b1011011, 0b1011111, 0b1110000, 0b1111111, 0b1111011};

pin tiene la lista de tus salidas del display 7 segmentos. Al tenerlas en un vector simplifica el uso.
segmentos tiene una lista de como visualizas los segmentos en tu display.
0bXXXXXXX es una notación en formato binario.
Solo copia como tenias definido cada número.
Donde tienes un HIGH yo puse un 1 empezando por el segmento a y terminando por el g
0babcdefg es como estan dispuestos

Si miras tu definición del 0 veras que tienes

HIGH 1
HIGH 1
HIGH 1
HIGH 1
HIGH 1
HIGH 1
LOW 0
eso conforma 0b1111110 para el 0 en la posición 0 del vector segmento.

2. Tus botones cambiaron a BtnContador y BtnUpDown

UpDown con cada cambio modifica la variable UpDown que sera 1 con UP y 0 con Down
Y en BtnContador con cada presión según este UpDown ira en forma ascendente o descendente.

Tienes razón, torpeza de mi parte

Modifica esto

Code: [Select]
void actualizarNumero() {
for (int i=0; i<7; i++){
digitalWrite(pin[i], segmento[cuenta]&(1<<(6-i)));
 }
}

Esta línea dice

Code: [Select]
1<<(6-i)
Desplazar a izquierda 6-i posiciones el valor de la diferencia.
Cuando i=0 => 6-i=6 y 1<<6 = 64 = 0x01000000

Y la operacion de segmento[cuenta] con (1<<(6-i)) hace esto.

Ejemplo: supongamos cuenta = 0
segmento[cuenta]=segmento[0]= 0b1111110
si estamos en el primero paso del for o sea i = 0
1<<(6-i) ==1<<(6-0)=1<<6=0b1000000
// 6543210 6543210
o sea que segmento[0] && (1<<6) = 0b1111110 && 0b1000000 =
como verás en la posición del bit 6 tenemos 1 en ambos bytes
asi que 1 && 1 = 1 y el bit enciende
asi ocurrirá en cada caso
para el bit 5 tenemos lo mismo
e igual hasta el bit 1 pero en el bit 0 segmento[cuenta] vale 0 y entonces no encenderà.

Esto se repite para cada caso tome el valor que tome cuenta lo que direccionará el valor del vector
segmento y siempre estaremos barriendo cada bit y como resultado de la operación lógica resultará
si debe encender o apagar.
Control de Display 7 Segmentos mediante Pulsadores
Por

José Villalaz

febrero 25, 2014

16384
En esta experiencia se mostrará cómo lograr el control de display de 7
segmentos mediante pulsadores. Para ello se utilizará botones tipo “push
button” los cuales aumentarán y disminuirán la cuenta mostrada en el display,
según sea necesario.

Una de las maneras más fáciles de controlar cierto tipo de proyecto es mediante el uso de
entradas (pulsadores) las cuales nos permiten manipular diferentes componentes. según
nuestras necesidades.

Para esta experiencia utilizamos los siguientes componentes:

 1 Protoboard.
 7 resistencias de 220Ω.
 2 resistencias de 4.7kΩ.
 1 display de 7 segmentos (cátodo común).
 Jumpers.
 1 Placa Arduino Uno.
 2 Pulsadores.

Podemos consultar la información que ya se ha publicado en este sitio web acerca del display
de 7 segmentos.

 Arduino y el display de 7 segmentos.

La configuración utilizada para este proyecto es la siguiente.

Control de Display 7 Segmentos mediante pulsadores.

R1= 220Ω R2=4.7KΩ

El pulsador es un dispositivo electrónico que funciona por lo general como un

interruptor eléctrico, es decir en su interior tiene dos contactos, al ser pulsado uno, se activará la
función inversa de la que en ese momento este realizando.

Cuando un pin del arduino no está conectado, el valor que nos devuelve la
función digitalRead() está indeterminado y puede variar aleatoriamente.

Debido a esto y para garantizar que la función nos devuelva un LOW cuando el botón no este
oprimido, debemos poner lo que se conoce como una resistencia pull down, en el lado del botón
conectado al pin de entrada. Esta resistencia pull down es una resistencia con un valor alto,
usaremos una de 4.7 KOhms, conectada al pin de tierra o GND del Arduino.
 Pulsador con resistencia
pull-down

De esta manera, cuando el botón está abierto, aseguramos tener un valor de 0 Volts o LOW,
dado por la resistencia pull down conectada a tierra y cuando el botón esté cerrado, tendremos
un valor de 5 Volts o HIGH. La resistencia pull down evitará que se forme un corto circuito
entre el botón y el GND.

Abrimos Arduino IDE y escribimos el siguiente código:

1 int BotonIncremento=9;//botón de incremento

2 int BotonDecremento=10;//botón de decremento

3 int timeAntirebote=15;//un valor entre 10 y 15 nos da una lectura correcta del estado del botón.

5 int cuenta=0;//lleva la cuenta

6 int EstadoBotonIncremento;

7 int EstadoBotonDecremento;

8 int EstadoBotonAnteriorIncremento;

9 int EstadoBotonAnteriorDecremento;

10

11 //Función Antirebote

12 boolean antirebote(int pin){//esta función nos va a devolver un valor booleano.

13 int contador=0;

14 boolean estado; //guarda el estado del botón

15 boolean estadoAnterior;//guarda el último estado del botón

16

17 do {

18 estado=digitalRead(pin);

19 if (estado != estadoAnterior){

20 contador=0;

21 estadoAnterior = estado;

22 }

23 else{

24 contador = contador + 1;

25 }

26 delay(1);

27 }

28 while(contador < timeAntirebote);

29 return estado;

30 }

31
32 void setup(){

33 pinMode(BotonIncremento,INPUT);//los botones los declaramos como entradas

34 pinMode(BotonDecremento,INPUT);

35 DDRD=B11111110;

36 }

37

38 void actualizarNumero(int valor){

39 //puerto 0 libre

40 //puerto 1 al 7 display

41 byte
numero[10]={B11111100,B00011000,B01101110,B00111110,B10011010,B10110110,B11110110,B00011100,B11111110,B10011110};
42
PORTD=numero[valor];
43
}
44

45
void loop() {
46
//Botón de Incremento.
47
EstadoBotonIncremento=digitalRead(BotonIncremento);//leemos el botón
48
if((EstadoBotonIncremento !=EstadoBotonAnteriorIncremento) &&(antirebote(BotonIncremento))){//preguntamos si hay cambio
49 respecto al estado anterior y vemos si esta presionado

50 cuenta++;//aumentamos la cuenta

51 if(cuenta>9){//aquí establecí un parámetro para respetar a la cuenta por asi llamarlo.

52 cuenta=0;//en este caso si es mayor que 9 se vaya a cero (0).

53 }

54 }

55 EstadoBotonAnteriorIncremento = EstadoBotonIncremento;//guardamos el estado del botón

56

57 //Botón de Decremento.

58 EstadoBotonDecremento=digitalRead(BotonDecremento);//leemos el estado del botón

59 if((EstadoBotonDecremento != EstadoBotonAnteriorDecremento)&&(antirebote(BotonDecremento))){

60 cuenta--;//disminuimos la cuenta

61 if(cuenta<0){

62 cuenta=9;
63 }

64 }

65 EstadoBotonAnteriorDecremento = EstadoBotonDecremento;

66 actualizarNumero(cuenta);

Uno de los problemas o dificultades que presenta el uso de pulsadores es que muchas veces la
señal no se comporta de manera limpia como nosotros queremos y esto ocasiona errores en
nuestro código; esto pasa porque Arduino ejecuta todo lo que está en la función loop muchas
veces, esto lo hace a una velocidad de millones de instrucciones por segundo. Entonces para
cuando soltemos el botón no sabemos en qué lugar quedo. Para ello crearemos una función
muy importante al momento de trabajar con pulsadores: la función Antirrebote.

En el sketch de este proyecto vamos a hacer uso de la función Antirrebote:

“Una función es un pedazo de código que no está escrito dentro de nuestra sección principal,
que sería dentro del loop.”

Una de las maneras de crear un antirrebote es mediante un delay(), sin embargo esta es una
manera muy brusca de hacerlo y aun así sigue generando errores.

El siguiente código es una forma concreta de hacer una lectura correcta al presionar el
pulsador. Para ello utilizamos el ciclo do-while.

1 boolean antirebote(int pin){//esta función nos va a devolver un valor booleano.

2 int contador=0;

3 boolean estado; //guarda el estado del botón

4 boolean estadoAnterior;//guarda el último estado del botón

6 do {

7 estado=digitalRead(pin);//leemos el estado del botón

8 if (estado != estadoAnterior){//comparamos el estado actual con el estado anterior

9 contador=0;//reiniciamos el contador

10 estadoAnterior = estado;

11 }

12 else{

13 contador = contador + 1;//aumentamos el contador en 1

14 }

15 delay(1);

16 }

17 while(contador < timeAntirebote);

18 return estado;

19 }

La variable timeAntirebote es una constante que escribimos al inicio y es el tiempo o la

duración que queremos usar para asegurarnos de tener un pulso estable, mientras más grande
sea este número más exacto será nuestra función antirrebote(), pero más tiempo necesitaremos
para comprobar el estado del pulsador. Un valor entre 10 y 15 nos da una lectura correcta del
estado del pulsador.

Otra de las funciones que utilicé en este código fue la de actualizarNumero, en la cual
incluí: Registro Port (Puerto) la cual me permitió reducir en gran tamaño el código.

Podemos leer más sobre esto en el siguiente post de Arduino:

 Registro Port (Puerto)

Código Utilizado:
 void setup(){
1
pinMode(BotonIncremento,INPUT);
2
pinMode(BotonDecremento,INPUT);
3
DDRD=B11111110;
4
}
5
void actualizarNumero(int valor){
6
byte
7 numero[10]={B11111100,B00011000,B01101110,B00111110,B10011010,B10110110,B11110110,B00011100,B11111110,B1001111
0};
8
PORTD=numero[valor];
9
}

Dato Curioso:

Los pines 0 y 1 son la transmisión serial (Rx y Tx respectivamente). Si colocamos en void

setup(): “Serial.begin()” y si usamos alguno de esos 2 puertos (como usé en el display), no
tiendrás comunicación serial. Esto se debe a que ambos pines son utilizados en el proceso de
comunicación serial con la computadora.

En este código utilice arrays (en el cual pude almacenar los diversos números del display).
Para definirlos se utiliza la expresión:

tipo_de_elemento nombre_del_array[número_de_elementos_del_array];
byte numero [10];

Podemos leer sobre esto en el siguiente post:

 Arrays en Arduino

Con este código podemos controlar los números en el display aumentándolo o disminuyéndolo
según nuestra necesidad.
Veamos algunas imágenes del circuito físico:

Circuito Físico

Circuito Físico

Espero que la información suministrada sea de su utilidad y comprensión.

Saludos.
 Contador binario con Arduino y registros DDR, PORT y PIN

Contador binario con Arduino y registros DDR,

PORT y PIN
Eduardo Lara febrero 25, 2015 Arduino, Basicos generales 3 comentarios

En este tutorial se diseñará un contador binario con Arduino. La salida del contador se representará mediante LEDS.
Entonces para crear el contador se utilizará el registro DDRX para la asignación de valores lógicos. Esto se realizará en el
lenguaje Arduino. En este tutorial aprenderemos cómo controlar las salidas digitales para mostrará los números del 1 al 31
de manera secuencial por medio de registro de puertos. Para realizar el contador es necesario tener conocimientos sobre
el código binario y quizás en como convertir binario a decimal.
CONTADOR BINARIO ASCENDENTE Y DESCENDENTE CON
ARDUINO
Un contador binario con Arduino, ascendete y desendente, permitirá cada determinado tiempo en incrementar o
decrementar el contador. Para este contador se utilizarán 5 leds de 5mm para representar a 5 bits de un numero binario. La
cuenta máxima de este contador será:

2^5 = 32-1 (-1 para considerar al 0).

Por lo tanto el numero máximo será el 31.

MATERIAL:
 Arduino UNO.
 5 LED 5mm.
 5 resistencias 220Ohm.
Los controladores y software Arduino lo puedes encontrar en: www.arduino.cc
REGISTROS DE PUERTOS EN ARDUINO
Para empezar los registros de puertos en Arduino nos permiten una manipulación más rápida de los pines de
Entradas/Salidas de la tarjeta Arduino UNO. Esta forma de programación es una alternativa al uso de las
clases pinMode y digitalWrite. El microcontrolador de esta placa tiene tres puertos:
 pin digital de 8-13. Puerto B. Controlador por DDRB, PORTB y PINB.
 pines de entrada analógica. Controlado por el puerto C, es decir, por DDRC, PORTC y PINC.
 pines digitales 0-7. El puerto D controlado por los registros DDRD, PORTD y PIND.
Cada uno de estos puertos está controlado por tres registros los cuales se definen por DDRX, PORTX y PINX.
PUERTO DDRX EN ARDUINO
El puerto DDRX en Arduino, sirve para determinar o configurar si el pin correspondiente será entrada o salida.

SINTAXIS:
DDRD= B00001111;
Donde:
D es el puerto a controlar

B indicamos que es el código binario

0 =entrada 1=salida
Con respecto a este ejemplo estamos declarando que la mitad de nuestro puerto sea entrada y la otra parte salida, entonces
con esto evitamos escribir varias veces “pinMode(x,OUTPUT)” para declarar cada pin.
Tomando en cuenta que el primer número de la derecha es el menos significativo la relación de los pines será de la
siguiente manera:
 Numero
insertado 0 0 0 0 1 1 1 1

Pin de
Arduino 7 6 5 4 3 2 1 0

Por otro lado si desea hacerlo en forma decimal solo bastaría con escribir “31” y esto sería igual a activar los primeros
cuatro pines como salida DDRD=31 o DDRD=255 si queremos activar todo el puerto como salida.

REGISTRO PORT EN ARDUINO

El registro PORT Controlada si el pin esta en alto o bajo. Es decir, que puede “escribir” un valor lógico a la salida de cada
pin.

PORTD=10101010
Por consiguiente los pines 1, 3, 5, 7 están en estado alto mientras que los pines 0, 2, 4, 6 están en estado bajo.

REGISTRO PIN
Lee el estado de los pines de entrada establecidos.

PIND
Se lee todo el puerto que se ha configurado como entrada. Este registro nos da un 1 si a un pin del microcontrolador se le
está alimentando externamente, y un cero si esta en nivel bajo de voltaje.

PROGRAMACIÓN DE CONTADOR BINARIO EN ARDUINO

Por consiguiente hacemos la programación del contador binario en el Arduino, en el cual declaramos una variable de tipo
entero para que cuente de manera ascendente y otra variable para descender el contador. Como resultado veremos como
encienden los LED’s en el puerto D.

CONEXIÓN DE CONTADOR BINARIO CON ARDUINO

La conexión del contador binario con ARduino, comienza con el circuito que se cablea cada uno de los pines de salida
que declaramos de nuestro Arduino a los LEDs que estas coincidan con el ánodo, y por el lado del cátodo se coloca una
resistencia de 220ohms en cada una de ellas. Para finalizar tomamos GND de Arduino y se une con todas las resistencias,
para poder observar el contador binario.
Diagrama esquemático
Conexión con contador binario