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 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
int outPin[] = {13, 12, 11, 10, 9}; int delayValue = 600; void setup() { int i = 0; for ( i = 0; i < 5; i++) pinMode(outPin[i], OUTPUT); } void loop() { int i = 0, j=0; for ( i = 0; i < 32; i++) { for ( j = 0; j < 5; j++) { if ( ( (i >> j) & 1 ) == 1 ) digitalWrite(outPin[j], HIGH); else digitalWrite(outPin[j], LOW); } delay(delayValue); } }
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 op eració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 ,
LED 1: 21 / 2 = 10 (01010 & 1) -> 0, apagado
LED 2: 21 / 4 = 5 (00101 & 1) -> 1,
LED 3: 21 / 8 = 2 (00010 & 1) -> 0, apagado
LED 4: 21 / 16 = 1 (00001 & 1) -> 1,
encendido
encendido
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. 2. 3. 4. 5. 6. 7. 8.
Un LED. Una tarjeta Arduino Uno-R3 o Arduino Mega 2560. Un cable USB impresora. Un computador. Cables para el montaje del circuito. Tarjeta Protoboard. Una Resistencia Eléctrica de 220 ohm. 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-conboton-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. 2. 3. 4. 5. 6. 7.
12 LEDs (Colores: Amarillo, Verde y Rojo). Una tarjeta Arduino Uno-R3 o Arduino Mega 2560. Un cable USB impresora. Un computador. Cables para el montaje del circuito. Tarjeta Protoboard. 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 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
//Estrella fugaz int pinArray [] = {2,3,4,5,6,7,8,9,10,11,12,13 }; // Vector donde se van a declara int waitStart= 200; // Tiempo entre encender un LED y otro int tailLength = 4; // Numero de LEDs activos int lineSize = 12; // Numero total de LEDs void setup() { int i; for (i=0; i< lineSize; i++) { pinMode(pinArray[i], OUTPUT); } } void loop() { int i; int tailCounter = tailLength; // Se establece un contador con los LEDS //que deben encenderse al mismo tiempoI set up the length in a counter
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 }
for (i=0; i 0) tailCounter--; } for (i=(lineSize-tailLength); i
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-encenderuna-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. 2.
4 Leds 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 Moni tor s eri al 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 PrenderLeds(0,0,1,0); } if (Numero == 5){ Serial.println("Numero PrenderLeds(1,0,1,0); } if (Numero == 6){ Serial.println("Numero PrenderLeds(0,1,1,0); } if (Numero == 7){ Serial.println("Numero PrenderLeds(1,1,1,0); } if (Numero == 8){ Serial.println("Numero PrenderLeds(0,0,0,1); } if (Numero == 9){ Serial.println("Numero PrenderLeds(1,0,0,1); } if (Numero == 10){ Serial.println("Numero PrenderLeds(0,1,0,1); } if (Numero == 11){ Serial.println("Numero PrenderLeds(1,1,0,1); } if (Numero == 12){ Serial.println("Numero PrenderLeds(0,0,1,1); } if (Numero == 13){ Serial.println("Numero PrenderLeds(1,0,1,1); } if (Numero == 14){ Serial.println("Numero PrenderLeds(0,1,1,1); } if (Numero == 15){ Serial.println("Numero PrenderLeds(1,1,1,1); } if (Numero > 15){ Serial.println("Numero PrenderLeds(0,0,0,0); } } }
cuatro 0010");
cinco 1010");
seis 0110");
siete 1110");
ocho 0001");
nueve 1001");
diez 0101");
once 1101");
doce 0011");
trece 1011");
catorce 0111");
quince 1111");
fuera de rango");
Vídeo: Para abrir el Moni tor s eri al 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 const int PinUpDown = 10;
= 9;
const int tiempoAntirebote = 10; int cuenta = 0; el botón byte BtnContador; byte BtnContadorAnt; byte BtnUpDown; byte BtnUpDownAnt; byte UpDown = true; decremetna
*/
// boton de Incr conectado al pin 10 // boton de Decr conectado al pin 9
// lleva la cuenta de las veces que presionamos
// UpDown = true incrementa Updown = false
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; boolean estadoAnt;
// guarda el estado del botón // 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); pinMode(PinUpDown, INPUT); }
// declaramos los botones como entradas
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; BtnUpDown = digitalRead(PinUpDown); if(BtnUpDown != BtnUpDownAnt) { if (antirebote(PinUpDown)) { UpDown = !UpDown; disminuimos la cuenta en 1 } } BtnUpDownAnt = BtnUpDown; actualizarNumero(); }
// guardamos el estado del botón // leemos el estado del botón // si hay cambio con respecto al estado Ant // checamos si está presionado y si lo está, //
// guardamos el estado del botón // 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 simpli fica 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 0 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. 4 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 5 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 byte numero [10];
nombre_del_array[número_de_elementos_del_array];
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, p ermitirá 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 pu ertos: 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: DDR D= 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
7
6
5
4
3
2
1
0
Pin de Arduino
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 h a 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
