Informe 6 lab digitales

Vista previa del material en texto

Entradas/salidas digitales
Informe #6
Paternina Fuentes Jhon Jairo
Ceballos Betancur Laura Yuliana
Universidad de Antioquia
Facultad de Ingeniería
Departamento de Ingeniaría Eléctrica
Laboratorio de circuitos digitales
Medellín
2021 1
Introducción
Para el ingeniero electricista, dentro de su labor, en la electrónica digital, es común encontrarse muy a menudo con el Display de 7 segmentos, el cual es un dispositivo optoelectrónico que permite visualizar números del 0 al 9.
Existen dos tipos de Display, de cátodo común y de ánodo común.
Este tipo de elemento de salida digital o Display, se utilizaba en los primeros dispositivos electrónicos de la década de los 70’s y 80’s.
Hoy en día es muy utilizados en proyectos educativos o en sistemas vintage. También debido a su facilidad de uso, mantenimiento y costo, son utilizados en relojes gigantes o incluso como marcadores en algunos tipos de canchas deportivas.
A continuación, se diseñan 2 circuitos conversores numéricos, el primero corresponde a un circuito conversor de binario 4 bits a hexadecimal con 1 Display de 7 segmentos, y el segundo corresponde a un conversor binario de 4 bits a decimal con 2 Display de 7 segmentos.
.
Objetivos
· Simplificar funciones lógicas con el Mapa de K.
· Diseñar circuitos combinacionales.
· Utilizar software de diseño de circuitos digitales.
	
Equipos y elementos necesarios
· Arduino UNO, software y demás elementos
Resumen de la consulta previa
¿Qué son resistencias de pull-up y pull-Down?
· resistencia pull down
En la configuración Pull Down, cuando el circuito está en reposo, la caída de tensión en la resistencia es prácticamente 0V (LOW), en cambio sí pulsamos P1, dejará pasar la corriente y tendremos una diferencia de potencial de 5V (HIGH). Este es el uso normal del estado LOW y HIGH.
· Resistencia Pull Up
Por el contrario, en la configuración Pull Up, cuando el circuito está en reposo, P1 sin pulsar, la caída de tensión es de 5V (HIGH), en cambio cuando pulsamos P1 se deriva toda la corriente a masa y la caída de tensión es 0V (LOW).
Normalmente las resistencias que se utilizan en estos casos son de 10K. Como hemos comprobado, estas dos configuraciones nos evitarán que en estado de reposo midamos un valor erróneo eliminando la influencia de factores externos sobre nuestras mediciones como el ruido eléctrico.
· Resistencia Pull Up con Arduino
En Arduino podemos aplicar una resistencia Pull Up en las entradas digitales a través de código. Simplemente poniendo un pin en modo INPUT_PULLUP con la instrucción pinMode.
 Resulta muy sencillo y nos evitará tener que añadir más elementos a nuestros circuitos.
¿QUÉ ES EL CÓDIGO BCD?
Decimal Codificado en Binario o Binary-Coded Decimal (BCD) es un estándar para representar números decimales en el sistema binario, en donde cada dígito decimal es codificado con una secuencia de 4 bits. Con esta codificación especial de los dígitos decimales en el sistema binario, se pueden realizar operaciones aritméticas como suma, resta, multiplicación y división.
Cada dígito decimal tiene una representación binaria codificada con 4 bits:
	DECIMAL
	BCD
	0
	0000
	1
	0001
	2
	0010
	3
	0011
	4
	0100
	5
	0101
	6
	0110
	7
	0111
	8
	1000
	9
	1001
¿QUÉ SON LOS DISPLAYS DE SIETE SEGMENTOS?
El Display de siete segmentos o Visualizador de siete segmentos en una forma de representar caracteres en equipos electrónicos. Está compuesto de siete segmentos que se pueden encender o apagar individualmente. Cada segmento tiene la forma de una pequeña línea.
El Display de siete segmentos es un elemento o componente que se utiliza para representar normalmente números, en muchos dispositivos electrónicos, debido a que es una manera muy simple de realizarlo. Por fuera, se diferencian mucho de los leds de uso típico, pero por dentro están constituidos por una serie de leds con conexiones predeterminadas de manera estratégica para que puedan formar un número “8”.
El visualizador de 7 segmentos es un componente que se utiliza para la representación de caracteres (normalmente números) en muchos dispositivos electrónicos, debido en gran medida a su simplicidad. Aunque externamente su forma difiere considerablemente de un led típico, internamente están constituidos por una serie de leds con unas determinadas conexiones internas, estratégicamente ubicados de tal forma que forme un número '8'.
Cada uno de los segmentos que forman la pantalla están marcados con siete primeras letras del alfabeto ('a'-'g'), y se montan de forma que permiten activar cada segmento por separado, consiguiendo formar cualquier dígito numérico. A continuación, se muestran algunos ejemplos:
· Si se activan o encienden todos los segmentos se forma el número "8".
· Si se activan sólo los segmentos: "a, b, c, d, e, f," se forma el número "0".
· Si se activan sólo los segmentos: "a, b, g, e, d," se forma el número "2".
· Si se activan sólo los segmentos: "b, c, f, g," se forma el número "4".
En algunos casos aparece un octavo segmento denominado dp. (del inglés decimal point, punto decimal).
Los leds trabajan a baja tensión y con pequeña potencia, por tanto, podrán excitarse directamente con puertas lógicas.
Normalmente, se utiliza un codificador decimal/BCD que, activando una sola pata de la entrada del codificador, activa las salidas correspondientes mostrando el número deseado.
¿QUÉ DIFERENCIAS EXISTEN ENTRE UN DISPLAY DE SIETE SEGMENTOS CON ÁNODO Y CON CÁTODO COMÚN?
En los de tipo de ánodo común, todos los ánodos de los leds o segmentos están unidos internamente a una patilla común que debe ser conectada a potencial positivo (nivel “1”).
El encendido de cada segmento individual se realiza aplicando potencial negativo (nivel “0”) por la patilla correspondiente a través de una resistencia que limite el paso de la corriente.
En los de tipo de cátodo común, todos los cátodos de los leds o segmentos están unidos internamente a una patilla común que debe ser conectada a potencial negativo (nivel “0”).
El encendido de cada segmento individual se realiza aplicando potencial positivo (nivel “1”) por la patilla correspondiente a través de una resistencia que limite el paso de la corriente.
Estructura básica de un programa en arduino: setup y loop
La estructura básica de programación de Arduino es bastante simple y divide la ejecución en dos partes: setup y loop. Setup() constituye la preparación del programa y loop() es la ejecución. En la función Setup() se incluye la declaración de variables y se trata de la primera función que se ejecuta en el programa. Esta función se ejecuta una única vez y es empleada para configurar el pinMode (p. ej. si un determinado pin digital es de entrada o salida) e inicializar la comunicación serie. La función loop() incluye el código a ser ejecutado continuamente (leyendo las entradas de la placa, salidas, etc.).
 
void setup() { 
 inMode(pin, OUTPUT); 	// Establece 'pin' como salida 
} 
void loop() {
 digitalWrite(pin, HIGH);	// Activa 'pin'
 delay(1000); 		// Pausa un segundo 
 digitalWrite(pin, LOW); 	// Desactiva 'pin'
 delay(1000);
} 
Como se observa en este bloque de código cada instrucción acaba con; y los comentarios se indican con //. Al igual que en C se pueden introducir bloques de comentarios con /* ... */.
Tipos de variables que se pueden utilizar: ¿dónde se declaran?
Una variable debe ser declarada y opcionalmente asignada a un determinado valor. En la declaración de la variable se indica el tipo de datos que almacenará (int, float, long)
int inputVariable = 0; 
Una variable puede ser declarada en el inicio del programa antes de setup(), localmente a una determinada función e incluso dentro de un bloque como pueda ser un bucle. El sitio en el que la variable es declarada determina el ámbito de la misma. Una variable global es aquella que puede ser empleada en cualquier función del programa. Estas variables deben ser declaradas al inicio del programa (antes de la función setup()).int v; 			// 'v' es visible en todo el programa
void setup() { 
			// no se requiere setup 
} 
void loop() { 
 for (int i=0; i<20;)	// 'i' es visible solo en el bucle
 i++; 
 float f;	// 'f' es visible únicamente en la función loop()
}
Tipos de datos que se pueden utilizar: ¿dónde se declaran?
Los datos que guardamos en las variables pueden ser de diferentes tipos, vamos a listar algunos de ellos. 
· char, se utilizan para almacenar caracteres, ocupan un byte.
· byte, pueden almacenar un número entre 0 y 255.
· int, ocupan 2 bytes (16 bits), y por lo tanto almacenan número entre 2-15 y 215-1, es decir, entre -32,768 y 32,767.
· unsigned int, ocupa trambién 2 bytes, pero al no tener signo puede tomar valores entre 0 y 216-1, es decir entre 0 y 65,535.
· long, ocupa 32 bits (4 bytes), desde -2,147,483,648 a 2,147,483,647.
· unsigned long.
· float, son números decimales que ocupan 32 bits (4 bytes). Pueden tomar valores entre -3.4028235E+38 y +3.4028235E+38.
· double, también almacena números decimales, pero disponen de 8-bytes (64 bit).
Siempre que elegimos un tipo de dato debemos escoger el que menos tamaño necesite y que cubra nuestras necesidades, ya que ocuparán espacio en la memoria de nuestra placa y podría darse el caso de que nuestro programa requiera más memoria de la disponible.
Pero, ¿cómo “hacemos” variables en nuestro código? Es muy sencillo: indicando el tipo y el nombre de la variable. Además, podemos darle o no un valor inicial. 
	1
2
3
4
5
	char miCaracter='a'; //declaramos una variable tipo char, llamada miCarcater y la inicializamos con valor a
byte unNumero = 189; // variable tipo byte inicializada a 189
int unEntero; //variable tipo int sin inicializar
unsigned int numeroPositivo = 2343; //entero positivo inicializada
float numDecimal = 12.212; //numero decimal inicializado a 12,212
Hay otro tipo muy importante, String, sirve para almacenar cadenas de texto, y es fundamental a la hora de enviar texto por el puerto serie. Permite crear cadenas a partir de número, otras variables, o concatenando cadenas
	1
2
3
4
5
	String stringOne = "Hello String";                  // using a constant String
String stringOne =  String('a');                    // converting a constant char into a String
String stringTwo =  String("This is a string");    // converting a constant string into a String object
String stringOne =  String(stringTwo + " with more");// concatenating two strings
String stringOne =  String(13);                     // using a constant integer
Existe aún otro tipo importante, llamado array, que es una agrupación ordenada de datos de un tipo determinado. De momento no lo vamos a ver… vamos a ir poco a poco.
Vamos a hacer un programa de ejemplo que suma dos enteros y muestra el resultado por puerto serie
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
	int a = 5; //variable a es un entero, inicializado a 5
int b = 6; //variable b es un entero, iniciazliado a 6
int c = a + b; //variable c es un entero, inicializado a 11.
 
void setup()
{
	// initialize Serial
	Serial.begin(9600); // baudrate 9600
	Serial.print("a + b equals ");
	Serial.println(String(c));	
}
 
void loop()
{
}
En este programa hemos escrito todo en la función setup ya que queremos que se ejecute solo una vez. ¿Cuál de estas tres opciones crees que se imprimirá por el puerto serie?
1. a + b equals c
2. 5 + 6 equals 11
3. a + b equals 11
Vas a tener que hacer tú mismo el problema para comprobar si has acertado.
Ámbito de las variables
Vamos a explicar esto mediante ejemplos.
Ámbito global
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
	int a= 5;
 
void setup()
{
	// initialize Serial
	Serial.begin(9600); // baudrate 9600
	Serial.println(String(a));
	Serial.println("fin setup");
	
}
 
void loop()
{
	a = a + 1;
	Serial.println(String(a));
	delay(1000);
}
Decimos que la variable a es global porque se puede acceder a ella desde cualquier parte, es decir, estamos accediendo a su valor desde las funciones setup y loop.
Lo que obtendríamos por el puerto serie sería lo siguiente:
Ámbito local
Son variables que solo existen dentro del ámbito en el que han sido declaradas. Por entendernos rápidamente, un ámbito es lo que está entre llaves. Si las utilizamos fuera de su ámbito tendremos un error de compilación. Al existir solo dentro de su ámbito mi programa podría repetir el mismo nombre de variable en distintos ámbitos. 
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
	void setup()
{
	int a= 5; //la variable a solo existe dentro de la función setup
	// initialize Serial
	Serial.begin(9600); // baudrate 9600
	Serial.println(String(a));
	Serial.println("fin setup");
	
}
 
void loop()
{
	//al compilar daría un error de compilación, porque a no existe en loop
	a = a + 1;
	Serial.println(String(a));
	delay(1000);
}
Al compilar este programa obtendremos un error de código, por la variable int a es de ámbito local, y solo existe dentro de la función setup por lo que no la podemos usar en la función loop.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
	void setup()
{
	int a = 5; //la variable a solo existe dentro de la función setup
	// initialize Serial
	Serial.begin(9600); // baudrate 9600
	Serial.println(String(a));
	Serial.println("fin setup");
	
}
 
void loop()
{
	int a = 0;
	a = a + 1;
	Serial.println(String(a));
	delay(1000);
}
¿Compila? Sí, porque a ha sido declarada tando dentro del loop como dentro del setup. ¿Qué se imprimiría en el monitor del puerto serie?
	1
2
3
4
5
	5
fin setup
1
1
1
Seguro que te he pillado… ¿esperabas que se imprimiera 1 2 3 4 …? Sí, cualquiera lo hubiera esperado. ¿Por qué no? Porque la variable a del loop se crea y se destruye en cada iteración, por lo que siempre se inicializa a 0 y se le añade 1… Por lo tanto, siempre vale 1 dentro del loop.
¿Y los siguientes programas? A ver si lo adivinas, hazlos tú mismo para comprobar el resultado.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
	int a = 0;
 
void setup()
{
	int a = 5; //la variable a solo existe dentro de la función setup
	// initialize Serial
	Serial.begin(9600); // baudrate 9600
	Serial.println(String(a));
	Serial.println("fin setup");
	
}
 
void loop()
{
	a = a + 1;
	Serial.println(String(a));
	delay(1000);
}
Arduino
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
	int a = 0;
 
void setup()
{
	int a = 5;
	a = a + 1;
	// initialize Serial
	Serial.begin(9600); // baudrate 9600
	Serial.println(String(a));
	Serial.println("fin setup");
	
}
 
void loop()
{
	a = a + 1;
	Serial.println(String(a));
	delay(1000);
}
Estructura de control: if…else
El bucle if...else permite un mayor control del flujo de código que la instrucción básica if, al permitir múltiples comprobaciones agrupadas. Por ejemplo, se puede comprobar una entrada analógica y realizar una acción si el valor de la entrada es menor que 500, y realizar otra acción distinta si la entrada es 500 o mayor. El código se vería así:
if (pinFiveInput < 500)
  {
     // acción A 
  } 
  else 
  { 
     // acción B 
  }
else puede ir precedido de otra condición de manera que se pueden establecer varias estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean mutuamente excluyentes pudiéndose ejecutar a la vez. Es incluso posible tener un número ilimitado de estos condicionales. Recuerde sin embargo qué sólo un conjunto de declaraciones se llevará a cabo dependiendo de la condición probada:
Tenga en cuenta que un bloque if...else se puede utilizar con o sin un bloque de terminación else y viceversa. Se permite un número ilimitado de dichas ramificaciones if...else.
if (pinFiveInput < 500) 
  { 
     // instrucciones A 
  } 
else if (pinFiveInput >= 1000) 
  { 
     // instrucciones B 
  } 
else 
 {
     // instrucciones C
 }
Procedimiento y Resultados
Diseñar el siguiente circuito combinacional, para lo cual es necesario:
· Analizar cuidadosamente el enunciado.
· Identificar entradas y salidas.
· Plantear una tabla de verdad.
· Obtener las ecuaciones lógicas y simplificadas con mapa de Karnaugh.
1- Diseñe un conversor binario (4 bits ingresadosa través de Dip Switch) a hexadecimal, utilizando un display de 7 segmentos: 
Esta es la tabla de verdad para el conversor binario:
	TABLA DE VERDAD
	HEX
	A
	B
	C
	D
	a
	b
	c
	d
	e
	f
	g
	0
	0
	0
	0
	0
	1
	1
	1
	1
	1
	1
	0
	1
	0
	0
	0
	1
	0
	1
	1
	0
	0
	0
	0
	2
	0
	0
	1
	0
	1
	1
	0
	1
	1
	0
	1
	3
	0
	0
	1
	1
	1
	1
	1
	1
	0
	0
	1
	4
	0
	1
	0
	0
	0
	1
	1
	0
	0
	1
	1
	5
	0
	1
	0
	1
	1
	0
	1
	1
	0
	1
	1
	6
	0
	1
	1
	0
	1
	0
	1
	1
	1
	1
	1
	7
	0
	1
	1
	1
	1
	1
	1
	0
	0
	0
	0
	8
	1
	0
	0
	0
	1
	1
	1
	1
	1
	1
	1
	9
	1
	0
	0
	1
	1
	1
	1
	1
	0
	1
	1
	A
	1
	0
	1
	0
	1
	1
	1
	0
	1
	1
	1
	B
	1
	0
	1
	1
	0
	0
	1
	1
	1
	1
	1
	C
	1
	1
	0
	0
	1
	0
	0
	1
	1
	1
	0
	D
	1
	1
	0
	1
	0
	1
	1
	1
	1
	0
	1
	E
	1
	1
	1
	0
	1
	0
	0
	1
	1
	1
	1
	F
	1
	1
	1
	1
	1
	0
	0
	0
	1
	1
	1
Estas son las funciones con las cuales activaremos los leds del Display siete segmentos:
· 𝑓a = 𝐴'𝐶 + 𝐵𝐶 + 𝐶𝐷' + 𝐴'𝐵𝐷 + 𝐴𝐶'𝐷' + 𝐴𝐵'𝐶' + 𝐵′𝐶′𝐷′
· 𝑓b = 𝐴'𝐵' + 𝐵'𝐶' + 𝐴'𝐶'𝐷' + 𝐴'𝐶𝐷 + 𝐴𝐶'𝐷 + 𝐵′𝐶𝐷′
· 𝑓c = 𝐴'𝐶' + 𝐴'𝐷 + 𝐴'𝐵 + 𝐶'𝐷 + 𝐴𝐵′
· 𝑓d = 𝐴𝐶' + 𝐴𝐵'𝐷 + 𝐵𝐶'𝐷 + 𝐵𝐶𝐷' + 𝐴'𝐶𝐷' + 𝐴'𝐵'𝐶 + 𝐴′𝐵′𝐷′
· 𝑓e = 𝐴𝐵 + 𝐶𝐷' + 𝐴𝐶 + 𝐵′𝐶′𝐷′
· 𝑓ƒ = 𝐴𝐵' + 𝐴𝐶 + 𝐶'𝐷' + 𝐴'𝐵𝐶' + 𝐵𝐶𝐷′
· 𝑓g = 𝐶𝐷' + 𝐴'𝐵'𝐶 + 𝐴'𝐵𝐶' + 𝐴𝐵' + 𝐴𝐷
2- Implemente con arduino las funciones simplificadas utilizando los operadores booleanos:
(! logical not)
&& (logical and)
|| (logical or)
3- Implemente el mismo conversor utilizando estructuras if…else
Conclusiones
Mediante la realización de esta práctica evidenciamos que los Mapas de Karnaugh nos brindan una manera efectiva y sencilla de simplificar funciones algebraicas booleanas, gracias a esto fue bastante interesante el montaje de los dos conversores binarios a Hexadecimal.
Se comprobó la tabla de verdad y el resultado de las funciones algebraicas que se obtuvieron a través del Arduino en Tinkercad, además, se implementaron dos códigos con los cuales llegamos a los resultados esperados.
Bibliografía
Resistencias de pull up y pull down. Consultado (septiembre 2021) en:
https://programarfacil.com/blog/arduino-blog/resistencia-pull-up-y-pull-down/
Visualizador de 7 segmentos. Consultado (septiembre 2021) en:
https://es.wikipedia.org/wiki/Visualizador_de_siete_segmentos
Decimal decodificado a binario. Consultado (septiembre 2021) en:
https://es.wikipedia.org/wiki/Decimal_codificado_en_binario
Display de 7 segmentos. Consultado (septiembre 2021) en:
https://hetpro-store.com/TUTORIALES/display-7-segmentos-anodo-catodo-comun/
Estructura básica de un programa. Consultado (septiembre 2021) en:
Estructura básica de un programa (ua.es)
Variables en arduino. Consultado (septiembre 2021) en:
Variables en Arduino | DIWO (bq.com)
Tipos de datos. Consultado (septiembre 2021) en:
Arduino en español: if...else (manueldelgadocrespo.blogspot.com)
if…else. Consultado (septiembre 2021) en:
Arduino en español: if...else (manueldelgadocrespo.blogspot.com)