Pantalla de siete segmentos de interfaz con Esptop 10 usando Arduino IDE

ESP32 es una popular plataforma electrónica de código abierto que se puede utilizar para controlar e interactuar con una amplia variedad de dispositivos electrónicos, incluidas las pantallas de siete segmentos. Al usar el microcontrolador ESP32, es posible controlar fácilmente el estado de cada segmento en una pantalla de siete segmentos, lo que permite la creación de pantallas numéricas personalizadas y otros proyectos interactivos.

Este artículo cubre el siguiente contenido:

• 1: Introducción al segmento de siete
• 2: siete segmento pinout
• 3: Tipos de siete segmentos
• 4: Cómo verificar un segmento de siete es el ánodo común o el cátodo común
• 5: Interfaciendo siete segmento con ESP32
• 5.1: esquema
• 5.2: hardware
• 5.3: Instalación de la biblioteca requerida
• 6: Controle siete segmento usando biblioteca con ESP32
• 6.1: código
• 6.2: salida
• 7: Controle siete segmento sin usar la biblioteca ESP32
• 7.1: código
• 7.2: salida

1: Introducción al segmento de siete

Un siete segmento puede mostrar información numérica utilizando un programa de microcontroladores. Consiste en siete segmentos individuales, cada uno de los cuales se puede iluminar o desactivar de forma independiente para crear varios caracteres numéricos.

Una pantalla de siete segmentos funciona iluminando diferentes combinaciones de sus siete segmentos para mostrar caracteres numéricos. Cada segmento está controlado por un pin individual, que se puede activar o desactivar para crear el carácter numérico deseado. Cuando los segmentos se iluminan en la combinación correcta, el carácter numérico es visible para el espectador.

Al usar un microcontrolador ESP32 para controlar una pantalla de siete segmentos, el ESP32 envía señales a los pines específicos en la pantalla de siete segmentos, diciéndole qué segmentos encender o desactivar para mostrar un carácter numérico específico.

Esto se hace escribiendo un programa en el Arduino IDE (entorno de desarrollo integrado) utilizando el lenguaje de programación C ++. El programa utiliza la biblioteca Arduino para controlar el estado de cada segmento con comandos simples. El programa también se puede configurar para mostrar diferentes caracteres numéricos basados ​​en la entrada de sensores o interacción del usuario.

2: siete segmento pinout

La pantalla de siete segmentos generalmente tiene 10 Pins, con un pin para cada segmento, uno para el decimal y dos alfileres comunes. Aquí hay una tabla de la típica pinout:

Número de PIN	Nombre	Descripción
1	b	Pin de LED de arriba a la derecha
2	a	Pin más alto LED
3	VCC/GND	GND/VCC depende de la configuración: cátodo/ánodo común
4	F	Pin de LED superior izquierdo
5	gramo	Alfiler
6	DP	Pin de led
7	C	Pin de LED de abajo a la derecha
8	VCC/GND	GND/VCC depende de la configuración: cátodo/ánodo común
9	d	Pasador LED inferior
10	mi	Pin de LED inferior izquierdo

Cada segmento está etiquetado como A, B, C, D, E, F y G. El pin común se usa típicamente para controlar todos los segmentos a la vez. El pin común es activo o alto activo dependiendo de la pantalla.

3: Tipos de siete segmentos

Hay dos tipos principales de pantallas de siete segmentos:

• Cátodo común
• Ánodo común.

1: en un cátodo común Mostrar, todos los terminales negativos de los segmentos LED están conectados juntos.

2: en un ánodo común Mostrar, todos los terminales positivos de los segmentos LED están conectados.

4: Cómo verificar un segmento de siete es el ánodo común o el cátodo común

Para verificar el tipo de siete segmentos, solo necesitamos una herramienta simple - Multímetro. Siga los pasos para verificar el tipo de pantalla de siete segmentos:

1. Mantenga la pantalla de siete segmentos firmemente en la mano e identifique Pin 1 Usando el pinout explicado arriba.
2. Tomar un multímetro. Asumir el plomo rojo para positivo (+) y plomo negro del multímetro por negativo (-).
3. Establecer el multímetro en la prueba de continuidad.
4. Después de esa verificación, el funcionamiento del medidor se puede verificar tocando los cables positivos y negativos. Se producirá un sonido de pitido si el medidor funciona correctamente. De lo contrario, reemplace las baterías en su multímetro con uno nuevo.
5. Coloque el plomo negro en el pin 3 u 8 del multímetro. Ambos alfileres son comunes y conectados internamente. Seleccione cualquier pin.
6. Ahora coloque el plomo rojo o positivo del multímetro en otros pines de siete segmentos como 1 o 5.
7. Después de tocar la sonda roja si algún segmento brilla, la pantalla es un cátodo común.
8. Intercambiar los cables del multímetro si ningún segmento brilla.
9. Ahora conecte el cable rojo al pin 3 u 8.
10. Después de eso, coloque el plomo negro o negativo en los pasadores restantes de la pantalla. Ahora, si alguno de los brillos del segmento, su pantalla es un ánodo común, Como en el ánodo común, el pin positivo es común, y el resto está conectado a un suministro negativo.
11. Repita los pasos para verificar todos los demás segmentos de visualización uno por uno.
12. Si alguno de los segmentos no brilla, entonces será defectuoso.

Aquí hay una imagen de referencia para una prueba de siete segmentos utilizando un multímetro. Podemos ver que el plomo rojo está en el pin 8 y el negro está en el pin de segmento, por lo que estamos usando Ánodo común siete segmento:

5: Interfaciendo siete segmento con ESP32

Para interactuar una pantalla de siete segmentos con un ESP32, necesitará los siguientes materiales:

• Un microcontrolador ESP32
• Una pantalla de siete segmentos
• Un tablero
• Cables de jersey

Interfaces ESP32 con pantallas de siete segmentos en varios pasos simples.

1: Primero, conecte la pantalla de siete segmentos a la placa de pan.

2: A continuación, conecte el Arduino Nano con una pantalla de siete segmentos usando cables. El ESP32 se utilizará para enviar señales a la pantalla de siete segmentos, diciéndole qué segmentos encender o desactivar qué segmentos encender o desactivar.

3: Ahora escriba un código Arduino en IDE. El programa deberá enviar señales a los pines específicos en la pantalla de siete segmentos, diciéndole qué segmentos encender o apagar para mostrar un carácter numérico específico.

4: El IDE Arduino proporciona una biblioteca que usamos fácilmente el estado de cada segmento con comandos simples.

5: Una vez que el programa está escrito y cargado al ESP32, la pantalla de siete segmentos debe comenzar a mostrar los caracteres numéricos según el programa.

5.1: esquema

Para programar siete segmentos primero debemos diseñar el circuito y conectarlo con ESP32. El uso del siguiente esquema de referencia conecta su placa ESP32 con una pantalla de siete segmentos.

Siguiendo la tabla Pinout para la conexión ESP32 con una sola pantalla de siete segmentos:

Número de PIN	Nombre	Alfiler
1	b	D2
2	a	D15
3	Comunicarse	GND/VCC depende de la configuración: cátodo/ánodo común
4	F	D19
5	gramo	D21
6	DP	Pin de led
7	C	D4
8	Comunicarse	GND/VCC depende de la configuración: cátodo/ánodo común
9	d	D5
10	mi	D18

5.2: hardware

La imagen a continuación muestra el hardware de ESP32 y siete segmento:

5.3: Instalación de la biblioteca requerida

Después de conectar siete segmentos, necesitamos instalar una biblioteca en el Arduino IDE. Usando esta biblioteca, podemos programar fácilmente ESP32 con siete segmentos.

Ir a la búsqueda del administrador de la biblioteca Sevseg Biblioteca e instálelo en Arduino IDE.

6: Controle siete segmento usando biblioteca con ESP32

Después de instalar la biblioteca, escribiremos un código Arduino utilizando la misma biblioteca.

6.1: código

Abra IDE y cargue código dado a ESP32:

#Include "Sevseg.h " /*incluyó biblioteca de siete segmentos* /
Sevseg Sevseg; /*Crear una biblioteca de siete segmentos*/
Configuración vacía ()

byte sevensegments = 1; /*Número de siete segmento conectado*/
Byte CommonPins [] = ; /*Definir PIN común de siete segmento*/
byte ledsegmentPins [] = 15, 2, 4, 5, 18, 19, 21; /*Defina pines digitales ESP32 para siete segmentos*/
Resistentes de boolSegments = verdadero; /*Asignación de tipo booleano a los registros de los siete = segmento*/
sevseg.Begin (Common_anode, sevensegments, CommonPins, LEDSegmentPins, ResistorSegments);/ *Configuración de siete segmentos */
sevseg.setbrightness (80); /*Siete brillo del segmento*/

bucle vacío ()

para (int i = 0; i < 10; i++) /*Display number from 0 to 9 using for loop*/

sevseg.setNumber (i);
sevseg.refreshDisplay (); /*Actualizar la pantalla de siete segmentos después de cada iteración*/
retraso (1000); /*Retraso de tiempo para iteración de bucle*/

Código iniciado llamando al Sevseg biblioteca. Después de eso definimos el número de segmentos, estamos usando con ESP32. Los pines de segmento LED se definen para tableros ESP32. Cambie el pin de acuerdo con el tipo de ESP32 que está utilizando.

Cualquiera de los pines digitales ESP32 se puede usar.

A continuación, ya que estamos utilizando el tipo de ánodo común, por lo que lo hemos definido dentro del código.

En caso de cátodo común, reemplácelo con un siguiente código:

Por fin un para Se usa el bucle que mostrará dígitos de 0 a 9 y actualiza la pantalla cada vez que se muestra un número:

6.2: salida

Podemos ver siete segmentos que muestran números a partir de 0 a 9:

7: Controle siete segmento sin usar biblioteca con ESP32

Para controlar siete segmentos sin ninguna biblioteca, tenemos que definir manualmente los números dentro del código Arduino en su representación binaria.

7.1: código

Abra IDE y conecta ESP32. Después de eso, cargue el código de siete segmento dado a ESP32:

int segpins [] = 15, 2, 4, 5, 18, 19, 21;/*esp32 pin para siete segmento*/
byte segcode [10] [7] = /*matriz del número 0-9 en orden de A de G* /
// a b c d e f g
0, 0, 0, 0, 0, 0, 1, /*Muestra 0* /
1, 0, 0, 1, 1, 1, 1, /*Pantalla 1* /
0, 0, 1, 0, 0, 1, 0, /*Pantalla 2* /
0, 0, 0, 0, 1, 1, 0, /*Pantalla 3* /
1, 0, 0, 1, 1, 0, 0, /*Pantalla 4* /
0, 1, 0, 0, 1, 0, 0,, /*Pantalla 5* /
0, 1, 0, 0, 0, 0, 0, /*Pantalla 6* /
0, 0, 0, 1, 1, 1, 1, /*Pantalla 7* /
0, 0, 0, 0, 0, 0, 0, /*Pantalla 8* /
0, 0, 0, 0, 1, 0, 0, /*Pantalla 9* /
;
Void DisplayDigit (int digit) /*función para inicializar cada segmento* /

para (int a = 0; a < 7; a++)

DigitalWrite (segpins [a], segcode [dígito] [a]);/ * instruyendo los segmentos respectivos para los números de 0 a 9 */


Configuración vacía ()

para (int a = 0; a < 7; a++) // for loop for setting the pins as output*/

PinMode (segpins [a], salida);


bucle vacío ()

para (int b = 0; b < 10; b++)/* generating numbers from 0 to 9 */

DisplayDigit (b);/*Muestra los números generados*/
retraso (1000);

En el código anterior primero definimos los pines digitales para ESP32, donde se conectarán siete segmentos. Se inicializa una matriz para definir el número de 0 a 9.

Siguiente dentro de la matriz Los 10 dígitos a partir de 0 a 9 se definen en su representación binaria.

Siguiente en Configuración vacía () Se define la parte A para el bucle. Esto para bucle con la ayuda de pina la función establece los pines de siete segmentos como salida.

Por fin en vacío bucle() Se define la función Otro para bucle que generará un número de 0 a 9 cada vez que se ejecute el programa.

7.2: salida

Aquí podemos ver que todos los números definidos dentro del código utilizando su equivalente binario se muestran en siete segmentos:

Conclusión

En conclusión, la interfaz de una pantalla de siete segmentos con un microcontrolador ESP32 es un proceso simple que se puede hacer con algunos materiales básicos y un poco de conocimiento de programación. Con un código ESP32 y Arduino, puede controlar fácilmente el estado de cada segmento en una pantalla de siete segmentos, lo que permite la creación de pantallas numéricas personalizadas y otros proyectos interactivos.