MICROCONTROLADORES
Laboratorio Nº 10
Programación con Display
de 7 segmentos
1. CAPACIDAD TERMINAL:
● Utilizar al microcontrolador en aplicaciones de control electrónico.
● Desarrollar y ejecutar programas en un microcontrolador PIC
● Programar y configurar interfaces básicas del microcontrolador.
● Conocer las técnicas de multiplexación.
● Programar HMI para juego de encestar.
● Utilizar al microcontrolador en aplicaciones de control electrónico.
● Desarrollar y ejecutar programas en un microcontrolador PIC
● Programar y configurar interfaces básicas del microcontrolador.
2. COMPETENCIA ESPECÍFICA DE LA SESIÓN:
● Conocer el Display de 7 segmentos y su funcionamiento.● Conocer las técnicas de multiplexación.
● Programar HMI para juego de encestar.
3. CONTENIDOS A TRATAR:
● Display 7 segmentos● Multiplexación de datos
4. RESULTADOS:
●Diseñan y optimizan sistemas y procesos para cumplir con las condiciones establecidas y gestionando adecuadamente los recursos materiales y humanos.
● Display de 7 segmentos de cátodo común:
Es un componente electrónico muy utilizado para representar visualmente números y letras, es de gran utilidad dado su simpleza para implementar en cualquier proyecto electrónico. Está compuesto por 7 dispositivos lumínicos (Led) que forman un “8”, de esta forma controlando el encendido y apagado de cada led, podremos representar el numero o letra que necesitamos.
En los 7 segmentos de Cátodo Común, el punto circuital en común para todos los Led es el Cátodo (Gnd), cero volt. Para controlar el número que queremos mostrar en el display, nos basamos en la siguiente tabla de verdad dado el caso que corresponda.
● Tipos de variables:
Sin embargo el compilador CCS también admite los siguientes tipos de datos definidos en el estándar C y que son los que normalmente se utilizan a la hora de programar:
ENTERO:
Se usan para representar números enteros que pueden ser tanto positivos como negativos.
Los tipos de datos enteros son: short, int, long y long long, cada uno representando un número entero de un tamaño o capacidad determinado. Según el compilador y la plataforma de hardware, cada uno de estos tipos de dato puede ocupar desde 1 byte hasta 8 bytes en memoria.
Además, se hace la distinción de si el entero es con signo (signed) o sin signo (unsigned). En caso de que no se declare si es con signo o sin signo, se toma con signo.
Algunos ejemplos de declaraciones de enteros:
int a;
unsigned int a;
signed long a;
signed long long a = 10000000;
ENTERO CON SIGNO:
Representa a los datos que abarcan los valores tanto en positivos como negativos: del -2147483648 al 2147483647. Esto en caso se disponga de 4 bytes de memoria, si se quiere almacenar el número.
ENTERO SIN SIGNO:
Representa un dato entero que sólo puede ser positivo, definido usando unsigned char, unsigned int, unsigned short, unsigned long o unsigned long long. Entre los valores: del 0 al 4294967295. Esto en caso se disponga de 4 bytes de memoria, si se quiere almacenar el número.
NÚMEROS FLOTANTES DE PUNTOS O REALES:
Representan a los números reales (números fraccionarios), definido usando el float y el double, que son 4 bytes y 8 bytes respectivamente. Se les utiliza tanto para representar números decimales, como números enteros con un orden de magnitud muy grande.
La forma de declarar una variable flotante es escribiendo en una línea uno de los tipos de datos flotantes y a continuación el nombre de la variable y tal vez algún valor que se les quiera dar.
Algunos ejemplos:
float a;
double a = 1e23;
double a = 3.1416;
float a = 4e-9;
double a = -78;
Hay que tener en cuenta que los valores flotantes son más convenientes para algunas aplicaciones, pero también hay casos en los que se prefieren los enteros. Esto se debe a que los números flotantes no necesariamente tienen soporte de hardware, en particular en las plataformas integradas. Una alternativa que se utiliza en estas situaciones es interpretar los enteros como decimales de forma que 150 se interprete como 1.5 y 2345 como 23.45.
CARACTERES:
Los caracteres se representan utilizando el tipo char, que tiene sólo 1 byte de tamaño. Este tipo se utiliza para representar los 256 caracteres de la tabla de caracteres del sistema. El tipo char es también un tipo entero, ya que puede tomar valores de 0 a 255. Por lo tanto también puede ser signed o unsigned.
En cuanto a la forma de declarar variables de tipo char es la misma forma que con los otros tipos.
Algunos ejemplos:
char a;
char a = 's';
unsigned char a = 48;
En muchas situaciones se utiliza el tipo char para almacenar números pequeños, ya que ocupa en memoria sólamente un byte.
En los 7 segmentos de Cátodo Común, el punto circuital en común para todos los Led es el Cátodo (Gnd), cero volt. Para controlar el número que queremos mostrar en el display, nos basamos en la siguiente tabla de verdad dado el caso que corresponda.
La variables se utilizan para nombrar posiciones de memoria RAM. Se deben declarar obligatoriamente antes de utilizarlas, para ello se debe indicar el nombre y el tipo de dato que se utilizará. Se definen de la siguiente manera.
BÁSICO
*Por defecto o equivalencia
Todos los tipos excepto float son por defecto sin signo, aunque pueden llevar el especificador unsigned ó signed y su rango de valores será el que corresponda a su tipo básico.
El nombre de la variable no puede ser una palabra clave, ya que está reservada por el compilador para realizar unas funciones determinadas y los caracteres que podemos utilizar son las letras: a-z y A-Z (ñ o Ñ no está permitida), los números: 0-9 y el símbolo de subrayado _. Además hay que tener en cuenta que el primer carácter no puede ser un número.
ENTERO:
Se usan para representar números enteros que pueden ser tanto positivos como negativos.
Los tipos de datos enteros son: short, int, long y long long, cada uno representando un número entero de un tamaño o capacidad determinado. Según el compilador y la plataforma de hardware, cada uno de estos tipos de dato puede ocupar desde 1 byte hasta 8 bytes en memoria.
Además, se hace la distinción de si el entero es con signo (signed) o sin signo (unsigned). En caso de que no se declare si es con signo o sin signo, se toma con signo.
Algunos ejemplos de declaraciones de enteros:
int a;
unsigned int a;
signed long a;
signed long long a = 10000000;
ENTERO CON SIGNO:
Representa a los datos que abarcan los valores tanto en positivos como negativos: del -2147483648 al 2147483647. Esto en caso se disponga de 4 bytes de memoria, si se quiere almacenar el número.
ENTERO SIN SIGNO:
Representa un dato entero que sólo puede ser positivo, definido usando unsigned char, unsigned int, unsigned short, unsigned long o unsigned long long. Entre los valores: del 0 al 4294967295. Esto en caso se disponga de 4 bytes de memoria, si se quiere almacenar el número.
NÚMEROS FLOTANTES DE PUNTOS O REALES:
Representan a los números reales (números fraccionarios), definido usando el float y el double, que son 4 bytes y 8 bytes respectivamente. Se les utiliza tanto para representar números decimales, como números enteros con un orden de magnitud muy grande.
La forma de declarar una variable flotante es escribiendo en una línea uno de los tipos de datos flotantes y a continuación el nombre de la variable y tal vez algún valor que se les quiera dar.
Algunos ejemplos:
float a;
double a = 1e23;
double a = 3.1416;
float a = 4e-9;
double a = -78;
Hay que tener en cuenta que los valores flotantes son más convenientes para algunas aplicaciones, pero también hay casos en los que se prefieren los enteros. Esto se debe a que los números flotantes no necesariamente tienen soporte de hardware, en particular en las plataformas integradas. Una alternativa que se utiliza en estas situaciones es interpretar los enteros como decimales de forma que 150 se interprete como 1.5 y 2345 como 23.45.
CARACTERES:
Los caracteres se representan utilizando el tipo char, que tiene sólo 1 byte de tamaño. Este tipo se utiliza para representar los 256 caracteres de la tabla de caracteres del sistema. El tipo char es también un tipo entero, ya que puede tomar valores de 0 a 255. Por lo tanto también puede ser signed o unsigned.
En cuanto a la forma de declarar variables de tipo char es la misma forma que con los otros tipos.
Algunos ejemplos:
char a;
char a = 's';
unsigned char a = 48;
En muchas situaciones se utiliza el tipo char para almacenar números pequeños, ya que ocupa en memoria sólamente un byte.
"Cada tipo de variable define sus límites. A char solo puede oscilar entre -128 y 127, mientras que a long puede oscilar entre -2,147,483,648 y 2,147,483,647 (long y otros tipos de datos numéricos pueden tener otro rango en diferentes computadoras, por ejemplo, desde -9,223,372,036,854,775,808 hasta 9,223,372,036,854,775,807 en una computadora de 64 bits)."
6. TAREA GUIADA DENTRO DEL LABORATORIO:
1.Transcriba el programa mostrado, compile dicho programa, simule en Proteus y compruebe funcionamiento en Tarjeta Entrenadora.
#include <16f877a.h> // Incluimos archivo con PIC a utilizar
#use delay (clock=20M) // Indicamos que trabajaremos a 20Mhz
#fuses HS, NOPROTECT, NOWDT // Configuración básica de los fusibles
int tabBCD[10]={0b00111111,0b00000110,0b01011011,0b01001111,0b01100110,
0b01101101,0b01111101,0b00000111,0b01111111,0b01101111};
int delay=5; // Completar con valor de retardo adecuado en ms
int16 dato=0; // Declaramos una variable ENTERA de 16 bits
int16 unidades=0, decenas=0, centenas=0;
int = 0;
/******************************************************/
// Funcion que descompone un número Entero de 4 cifras
/******************************************************/
void descomp_entero(int16 valor)
{
centenas = (int16) valor / 100; // 1er Dígito o Centenas
valor -= centenas * 100; // y se lo resto al valor
decenas = (int16) valor / 10; // 2do Dígito o Decenas
valor -= decenas * 10; // y también se lo resto
unidades = (int16) valor; // y por último solo me quedan las unidades
}
/*************************************************/
// Funcion para displayar en forma multiplexada
/************************************************/
void visualizar(void)
{
output_b(tabBCD[centenas]);
output_a(0b00001000);
delay_ms(delay);
output_b(tabBCD[decenas]);
output_a(0b00000100);
delay_ms(delay);
output_b(tabBCD[unidades]);
output_a(0b00000010);
delay_ms(delay);
}
/*************************************************/
// Funcion para emitir un pitido
/************************************************/
void BIP()
{
FOR (i=0;i<=100;++i)
{
output_high(PIN_E1); // Pone a "1" el pin E1 (envía 5 voltios)
delay_ms(1); // "Congela el tiempo" durante 1ms
output_low(PIN_E1); // Pone a "0" el pin E1
delay_ms(1); // "Congela el tiempo" durante 1ms
}
}
/*************************************************/
// FUNCION PRINCIPAL VOID (MAIN)
/************************************************/
void main ()
{
dato = 123; // ingrese numero inicial a visualizar
descomp_entero(dato);
visualizar(); // mostramos el valor de "dato" en displays
while(true)//1
{
IF (!input(PIN_E0)) // si pulsamos E0.....
{
dato = dato + 1; // el valor "dato" se incrementa en uno
descomp_entero(dato); // descomponemos el valor "dato"
delay_ms(300); // congelamos el tiempo para evitar falsos disparos
}
visualizar(); // mostramos el valor de "dato" en displays
}
}
|
7. TAREA A SER EVALUADA:
Realice las modificaciones que se sugieren al programa, experimente y responda las preguntas planteadas:
1. Se tiene un sistema con 2 pulsadores (D0, D1) de entrada y 3 displays de salida, además de un zumbador en el pin E1. Programe según lo siguiente:
a. Al empezar el programa, se debe mostrar el número 500.
b. Al presionar D0, el número mostrado se debe incrementar en 5 unidades, además debe zonar un pitido.
c. Al presionar D1, el número mostrado debe disminuir 5 unidades pero de de 1 en 1 cada segundo.
d. Si el número llega a ser mayor a 600, debe sonar 3 pitidos.
2. Describa el funcionamiento del programa previamente diseñado, demuestre funcionamiento mediante simulación y en tarjeta entrenadora. Grabe en video para evidencia.
1. Se tiene un sistema con 2 pulsadores (D0, D1) de entrada y 3 displays de salida, además de un zumbador en el pin E1. Programe según lo siguiente:
a. Al empezar el programa, se debe mostrar el número 500.
b. Al presionar D0, el número mostrado se debe incrementar en 5 unidades, además debe zonar un pitido.
c. Al presionar D1, el número mostrado debe disminuir 5 unidades pero de de 1 en 1 cada segundo.
d. Si el número llega a ser mayor a 600, debe sonar 3 pitidos.
2. Describa el funcionamiento del programa previamente diseñado, demuestre funcionamiento mediante simulación y en tarjeta entrenadora. Grabe en video para evidencia.
8. EVIDENCIA DE TRABAJO EN LABORATORIO:
Link del video: https://youtu.be/D6tesEcnlhY
9. OBSERVACIONES:
- Al simular la programación en el entrenador de Proteus, no se obtenía el mismo resultado de visualización a como se tenía en el módulo físico.
- Pese a aumentar el porcentaje de la resistencia variable en el entrenador Proteus a su 100% o valores próximos, los segmentos de cada dígito del display no se lograban ver de la manera correcta.
- El código que se implementó en físico, mostraba el funcionamiento propio de la programación realizada en este laboratorio.
10. CONCLUSIONES:
- Se conoció más de las funciones de las que tiene control un PIC 16F877A, en este caso se enfocó en la programación de conteo visualizado mediante displays de 7 segmentos, mostrando tres dígitos (centenas, decenas y unidades) y su previa catalogación del conexionado de sus pines en el PIC.
- Para obtener los datos calculados y llevarlos al lenguaje de la activación de los displays, debemos descomponer el dato que leemos; en este caso centenas, decena y unidades, empleando una serie de ecuaciones sucesivas y reemplazo de valores para obtener el dato de cada dígito.
- Para mostrar los datos obtenidos mediante los cálculos realizados, se crea la función visualizar que tomará los resultados obtenidos en los cálculos de la función anterior.
- Los retardos que se implementaron en la función de visualizar son mínimos ya que se requiere tener una muestra constante, de modo tal no es perceptible al ojo humano, cuando se realiza este cambio o parpadeo; sin embargo, si se le incrementa el valor de retardo podremos notar estos cambios.
