¿Qué es una pantalla de 7 segmentos? ¿Cómo se programa? ¿Cómo se integra en tu proyecto?

Introducción

Una pantalla de 7 segmentos es una técnica de visualización basada en segmentos. Se utiliza principalmente para mostrar números. Para mostrar letras, es mejor usar una pantalla LCD. La pantalla de 7 segmentos se usa ampliamente en calculadoras y relojes despertadores.

La pantalla de 7 segmentos, como su nombre indica, tiene 7 segmentos. Un segmento es una porción de la pantalla que permite mostrar un dígito. Dependiendo de qué segmentos estén iluminados, se muestran diferentes números. Con esta pantalla, puedes mostrar números del 1 al 9. La pantalla de 7 segmentos se codifica usando 8 bits.

¿Cómo se representan los números?

La pantalla está compuesta por 4 segmentos verticales y 3 segmentos horizontales. Los segmentos suelen disponerse en forma hexagonal así, pero también son posibles trapecios y rectángulos. Además, hay un punto que permite mostrar números decimales.

Aquí está la lista de dígitos que se pueden mostrar en una pantalla de 7 segmentos:

Las letras correspondientes a los pines deben conectarse al chip 74HC595. El menos (–) debe conectarse a la tierra (GND) de la placa Arduino.

Aquí tenemos un ejemplo de conexión para una pantalla de 7 segmentos con 6 pines a cada lado. Algunos pines (etiquetados con letras) están conectados al chip 74HC595, y hay un pin de punto decimal para mostrar números decimales. Finalmente, los pines D1 a D3 están conectados a la placa Arduino.

El chip CD4511

 

El decodificador CD4511 sirve como un puente entre la placa Arduino y la pantalla de 7 segmentos. No es obligatorio en tus circuitos; sin embargo, ayuda a simplificarlos, por lo que lo verás en los diagramas a lo largo de este curso.

Aquí tenemos un ejemplo de conexión para una pantalla de 7 segmentos con 6 pines a cada lado. Algunos pines (etiquetados con letras) están conectados al chip 74HC595, y hay un pin de punto decimal para mostrar números decimales. Finalmente, los pines D1 a D3 están conectados a la placa Arduino.

Permite mostrar números en pantallas de 7 segmentos sin tener que controlar manualmente el estado de cada segmento. Proporcionas el valor del dígito en binario (usando 4 bits) y él se encarga de la visualización.

Como puedes ver, hay letras correspondientes a las conexiones que deben hacerse con la pantalla.

¿Cátodo común o ánodo común?

Existen dos tipos de pantallas: ánodo común y cátodo común. Es importante entender que, para que fluya corriente, debe haber una diferencia de potencial entre dos puntos. Por ejemplo, para que un LED se encienda, el ánodo debe conectarse a 5V y el cátodo a GND. Esta diferencia de voltaje entre los dos pines genera la corriente.

El principio es exactamente el mismo aquí.

a) Ánodo común

Para este tipo de pantalla, el ánodo está conectado a 5V. Esto significa que, para que fluya corriente, los otros pines deben estar en bajo.

b) Cátodo común

Para pantallas de cátodo común, el cátodo está conectado a tierra. Esto significa que, para que fluya corriente, los pines controlados por Arduino deben estar en alto.

Para nuestros circuitos, hemos elegido pantallas de 7 segmentos con cátodo común.

Mostrar números en una pantalla de 7 segmentos

a) Pantalla de 7 segmentos simple

Ahora, veamos cómo mostrar un número en una pantalla de 7 segmentos de cátodo común.

/* Assign each LED to an Arduino pin */
unsigned const int A = 13;
unsigned const int B = 12;
unsigned const int C = 11;
unsigned const int D = 10;
unsigned const int E = 9;
unsigned const int F = 8;
unsigned const int G = 7;
unsigned const int H = 6;


void setup(void){
  // Define pins as outputs
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(H, OUTPUT);
}

// Then, we created different functions for each digit
void zero() {
  digitalWrite(A, LOW);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void un() {
  digitalWrite(A, LOW);
  digitalWrite(B, LOW);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void deux() {
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, LOW);
  digitalWrite(H, LOW);
}

void trois() {
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void quatre() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void cinq() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void six() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void sept() {
  digitalWrite(A, LOW);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void huit() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void neuf() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

// Now, we call the functions one by one
void loop(void)
{
  zero();
  delay(1000);// Pause to view the displayed number before moving to the next
  
  un();
  delay(1000);
  
  deux();
  delay(1000);
  
  trois();
  delay(1000);
  
  quatre();
  delay(1000);
  
  cinq();
  delay(1000);
  
  six();
  delay(1000);
  
  sept();
  delay(1000);
  
  huit();
  delay(1000);
  
  neuf();
  delay(1000);
}

b) Usando el chip CD4511

Ahora, veamos el mismo circuito con el chip CD4511.

const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;

void setup() {
    // Set pins as outputs
    pinMode(bit_A, OUTPUT);
    pinMode(bit_B, OUTPUT);
    pinMode(bit_C, OUTPUT);
    pinMode(bit_D, OUTPUT);

    // Start by displaying the number 0, so set all outputs to LOW
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);
}

void loop() {
    char i = 0; // counter variable
    for(i = 0; i < 10; i++) {
        display(i); // call the display function
        delay(500); // wait for half a second
    }
}

// function to display numbers
void display(char number) {
    // reset all decoder bits to LOW
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);

    // turn on the required bits
    if(number >= 8){
        digitalWrite(bit_D, HIGH);
        number = number - 8;
    }
    if(number >= 4){
        digitalWrite(bit_C, HIGH);
        number = number - 4;
    }
    if(number >= 2){
        digitalWrite(bit_B, HIGH);
        number = number - 2;
    }
    if(number >= 1){
        digitalWrite(bit_A, HIGH);
        number = number - 1;
    }
}