Interfaz de pantalla de 7 segmentos con microcontrolador pic

Este es nuestro octavo tutorial de aprendizaje de microcontroladores PIC utilizando MPLAB y XC8. Hemos avanzado desde la instalación de MPLABX hasta el uso de una pantalla LCD con PIC MCU. Si eres nuevo aquí, mira los tutoriales anteriores donde puedes aprender temporizadores, LED parpadeantes, LCD de interfaz, etc. Puedes encontrar todos nuestros tutoriales PIC aquí. En nuestro último tutorial vimos cómo podemos generar caracteres personalizados con nuestra pantalla LCD de 16 * 2, ahora vamos a equiparnos con otro tipo de módulo de pantalla llamado pantalla de 7 segmentos e interconectarlo con el microcontrolador PIC.

Aunque la pantalla LCD de 16x2 es mucho más cómoda que la pantalla de 7 segmentos, hay pocos escenarios en los que una pantalla de 7 segmentos sea más útil que una pantalla LCD. La pantalla LCD tiene el inconveniente de tener un tamaño de carácter bajo y será excesivo para su proyecto si solo planea mostrar algunos valores numéricos. Los 7 segmentos también tienen la ventaja contra condiciones de iluminación deficientes y pueden verse desde ángulos más grandes que una pantalla LCD normal. Entonces, comencemos a conocerlo.

Módulo de pantalla de 7 segmentos y 4 dígitos de 7 segmentos:

La pantalla de 7 segmentos tiene siete segmentos y cada segmento tiene un LED en su interior para mostrar los números iluminando los segmentos correspondientes. Por ejemplo, si desea que el segmento de 7 muestre el número "5", debe iluminar el segmento a, f, g, cyd haciendo que sus pines correspondientes sean altos. Hay dos tipos de pantallas de 7 segmentos: cátodo común y ánodo común, aquí estamos usando la pantalla de siete segmentos de cátodo común. Obtenga más información sobre la pantalla de 7 segmentos aquí.

Ahora sabemos cómo mostrar nuestro carácter numérico deseado en una sola pantalla de 7 segmentos. Pero, es bastante evidente que necesitaríamos más de una pantalla de 7 segmentos para transmitir cualquier información que tenga más de un dígito. Entonces, en este tutorial usaremos un módulo de pantalla de 7 segmentos de 4 dígitos como se muestra a continuación.

Como podemos ver, hay cuatro pantallas de siete segmentos conectadas entre sí. Sabemos que cada módulo de 7 segmentos tendrá 10 pines y para 4 pantallas de siete segmentos habría 40 pines en total y sería agitado para cualquiera soldarlos en una placa de puntos, por lo que recomendaría encarecidamente a cualquiera que compre un módulo. o haga su propia PCB para usar una pantalla de 7 segmentos de 4 dígitos. El esquema de conexión para el mismo se muestra a continuación:

Para comprender cómo funciona el módulo de siete segmentos de 4 dígitos, tenemos que mirar los esquemas anteriores, como se muestra, los pines A de las cuatro pantallas están conectados para reunirse como una A y lo mismo para B, C… hasta DP. Entonces, básicamente, si el gatillo A está activado, entonces las cuatro A deberían subir, ¿verdad?

Pero eso no sucede. Tenemos cuatro pines adicionales de D0 a D3 (D0, D1, D2 y D3) que se pueden usar para controlar qué pantalla de las cuatro debe subir. Por ejemplo: si necesito que mi salida esté presente solo en la segunda pantalla, entonces solo D1 debe hacerse alto mientras se mantienen los otros pines (D0, D2 y D3) tan bajos. Simplemente podemos seleccionar qué pantalla debe activarse usando los pines de D0 a D3 y qué carácter se mostrará usando los pines de A a DP.

Conexión del módulo de siete segmentos de 4 dígitos con el microcontrolador PIC:

Aquí hemos utilizado el microcontrolador PIC PIC16F877A y el esquema del circuito se muestra a continuación.

Tenemos 12 pines de salida del módulo, de los cuales 8 se usan para mostrar los caracteres y cuatro se usan para seleccionar una pantalla de cuatro. Por lo tanto, todos los pines de 8 caracteres se asignan a PORTD y los pines de selección de pantalla se asignan a los primeros cuatro pines de PORTC.

Nota: El pin de tierra del módulo también debe conectarse a la tierra de la MCU que no se muestra aquí.

Programación usando PIC16F877A:

Ahora que sabemos cómo funciona realmente este módulo, aprendamos a programar el PIC16F877A para que muestre un número de 4 dígitos. Incrementemos una variable de 0 a 1000 e imprimamos en la pantalla de 7 segmentos. Inicie el programa MPLABX y cree un nuevo proyecto, comencemos con los bits de configuración.

#pragma config FOSC = HS // Bits de selección del oscilador (oscilador HS) #pragma config WDTE = OFF // Bit de habilitación del temporizador de vigilancia (WDT deshabilitado) #pragma config PWRTE = ON // Bit de habilitación del temporizador de encendido (PWRT habilitado) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR habilitado) #pragma config LVP = OFF // Low-Voltage (suministro único) In-Circuit Serial Programming Enable bit (RB3 es E / S digital, HV encendido MCLR debe usarse para la programación) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code Protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (protección contra escritura desactivada; toda la memoria del programa puede ser escrito por el control EECON) #pragma config CP = OFF // Bit de protección de código de memoria de programa flash (protección de código desactivada)

Como de costumbre, usamos la ventana de configuración de bits para establecer estos bits. Si no está seguro de lo que significan, visite el tutorial de parpadeo de LED aquí.

A continuación, definamos los pines de salida para alternar entre cada dígito de la pantalla.

// *** Definir los pines de señal de las cuatro pantallas *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Fin de la definición ** ////

Aquí los pines RC0, RC1, RC2 y RC3 se utilizan para seleccionar entre los cuatro dígitos de nuestro módulo de visualización de 7 segmentos. Estos pines se definen como s1, s2, s3 y s4 respectivamente.

A continuación, saltemos a void main (), dentro del cual tenemos la siguiente declaración de variable:

int i = 0; // el valor de 4 dígitos que se mostrará int flag = 0; // para crear delay unsigned int a, b, c, d, e, f, g, h; // solo variables unsigned int seg = {0X3F, // Valor hexadecimal para mostrar el número 0 0X06, // Valor hexadecimal para mostrar el número 1 0X5B, // Valor hexadecimal para mostrar el número 2 0X4F, // Valor hexadecimal para mostrar el número 3 0X66, // Valor hexadecimal para mostrar el número 4 0X6D, // Valor hexadecimal para mostrar el número 5 0X7C, // Valor hexadecimal para mostrar el número 6 0X07, // Valor hexadecimal para mostrar el número 7 0X7F, / / Valor hexadecimal para mostrar el número 8 0X6F // Valor hexadecimal para mostrar el número 9}; // Fin de la matriz para mostrar números del 0 al 9

Aquí las variables i y bandera se utilizan para almacenar los valores que se muestran y la creación de un retraso, respectivamente. Las variables enteras sin signo de la aa la h se utilizan para dividir los números de cuatro dígitos en un solo dígito y almacenarlos (que se explicará más adelante aquí).

Una cosa clave a tener en cuenta aquí es la declaración de matriz "seg" . En este programa estamos usando un nuevo tipo de datos llamado Array. Array no es más que una colección de valores de tipo de datos similares. Aquí, hemos utilizado esta matriz para almacenar todos los valores hexadecimales equivalentes para mostrar un número del 0 al 9.

La dirección de la matriz siempre comienza desde cero. Entonces, esta matriz tendrá el valor hexadecimal de un número numérico (0-9) almacenado en la dirección que es la misma que la del número que se muestra a continuación

Variable:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Código hexadecimal:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Número numérico:	0	1	2	3	4	5	6	7	8	9

Así que simplemente, si desea mostrar el número 0 en su segmento 7, puede llamar a seg, de la misma manera si desea mostrar el número 6 solo tiene que usar seg.

Para comprender cómo se obtuvo realmente el valor HEX, miremos la siguiente tabla. El valor HEX equivalente para cada número decimal se almacena en la matriz para que se pueda llamar para mostrar un número en particular.

Ahora, pasemos a la siguiente parte del código, que es la configuración de E / S:

// ***** Configuración de E / S **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Fin de la configuración de E / S ** ///

La configuración de E / S es simple porque todos los pines de nuestro segmento de 7 son pines de salida, y las conexiones se muestran en el diagrama de circuito anterior, así que simplemente declarelas como salidas e inicialícelas a cero.

Ahora saltemos a nuestro bucle infinito (while (1)). Aquí tenemos que dividir el valor de "i" en cuatro dígitos y mostrarlos en el segmento de 7. Primero comencemos dividiendo el valor en "i"

// *** Dividir "i" en cuatro dígitos *** // a = i% 10; // El cuarto dígito se guarda aquí b = i / 10; c = b% 10; // Aquí se guarda el tercer dígito d = b / 10; e = d% 10; // Aquí se guarda el 2º dígito f = d / 10; g = f% 10; // El primer dígito se guarda aquí h = f / 10; // *** Fin de la división *** //

Utilizando una operación simple de módulo y división, el número de 4 dígitos (i) se separa en números individuales. En nuestro caso, tomemos un ejemplo donde el valor de "i" es 4578. Luego, al final de este proceso, la variable g = 4, e = 5, c = 7 y a = 8. Así que ahora será fácil mostrar cada dígito simplemente usando esa variable.

PORTD = seg; s1 = 1; // Encienda la pantalla 1 e imprima el cuarto dígito __delay_ms (5); s1 = 0; // Apagar la pantalla 1 después de un retardo de 5 ms PORTD = seg; s2 = 1; // Encienda la pantalla 2 e imprima el tercer dígito __delay_ms (5); s2 = 0; // Apaga la pantalla 2 después de un retardo de 5 ms PORTD = seg; s3 = 1; // Encienda la pantalla 3 e imprima el segundo dígito __delay_ms (5); s3 = 0; // Apague la pantalla 3 después de un retardo de 5ms PORTD = seg; s4 = 1; // Encienda la pantalla 4 e imprima el primer dígito __delay_ms (5); s4 = 0; // Apague la pantalla 4 después de un retraso de 5 ms

Este es el lugar real donde la MCU habla con el segmento 7. Como sabemos , podemos mostrar solo un dígito a la vez, pero tenemos cuatro dígitos para mostrar y solo si los cuatro dígitos están en el número completo de cuatro dígitos será visible para el usuario.

Entonces, ¿cómo vamos con esto?

Por suerte para nosotros, nuestro MCU es mucho más rápido que un ojo humano, entonces lo que realmente hacemos: mostramos un dígito a la vez, pero lo hacemos muy rápido como se muestra arriba.

Seleccionamos la visualización de un dígito y esperamos 5ms para que la MCU y el segmento 7 puedan procesarlo y luego apagamos ese dígito y pasamos al siguiente dígito y hacemos lo mismo hasta que alcancemos el último dígito. Este retraso de 5 ms no puede ser observado por un ojo humano y los cuatro dígitos parecían estar encendidos al mismo tiempo.

Eso es todo, finalmente simplemente incrementamos el valor del dígito mostrado usando un retraso como se muestra a continuación

if (bandera> = 100) // esperar hasta que la bandera llegue a 100 {i ++; bandera = 0; // solo si la bandera es cien "i" se incrementará} bandera ++; // indicador de incremento para cada flash

La demora se usa para que el tiempo necesario para cambiar de un número a otro sea lo suficientemente largo como para que notemos el cambio.

El código completo se proporciona a continuación y el proceso también se explica en el video al final.

Configuración y prueba de hardware:

Como siempre, simulemos el programa usando Proteus antes de utilizar nuestro hardware. Si la simulación tiene éxito, debería ver algo como esto

Este proyecto no tiene ninguna configuración de hardware complicada, nuevamente estamos usando la misma placa de microcontrolador PIC que hemos creado en el Tutorial de parpadeo de LED. Simplemente conecte el módulo de 7 segmentos con su placa de microcontrolador PIC de acuerdo con el diagrama de conexión. Una vez que haya terminado con las conexiones, simplemente descargue el código usando su programador PicKit 3 y disfrute de su salida.