Uso de una pantalla de 4×7 segmentos con Arduino

Para obtener información del Arduino sin conectarlo al odinador, es habitual utilizar una interfaz como la pantalla de 4×7 segmentos. Veremos en este tutorial cómo conectar y programar el arduino para mostrar la información en la pantalla.

Es posible conectar la pantalla de 7 segmentos directamente a los pines del Arduino. Para mantener los pines libres para otras funcionalidades, utilizamos un registro de desplazamiento 74HC595.

Material

• Ordenador
• Arduino UNO
• Pantalla de 4×7 segmentos
• Registro de desplazamiento 74HC595
• Cable Dupont
• Breadboard

Principio de funcionamiento

Los displays de 7 segmentos consisten en una serie de LEDs colocados para formar números. Estos LEDs se controlan a través de los pines de la pantalla (1-12).

Los grupos de LEDs o dígitos se activan a través de los pines D1,D2,D3,D4 y los LEDs se encienden a través de los pines A,B,C,D,E,F,G y DP para el punto decimal.

Existen dos tipos de pantallas, con cátodo común (serie A arriba) o con ánodo común (serie B abajo). Para la serie de ánodos, hay que conectar el común a 5V para activar el dígito y conmutar el pin LOW para encender un LED. En el caso de un cátodo común, hay que conectar el común a la tierra y poner el pin en estado ALTO para encender el LED.

Asegúrate de comprobar el modelo que tienes. En este tutorial, utilizamos la pantalla 5461BS de 4×7 segmentos con ánodo común.

Esquema

Utilizamos un registro de desplazamiento 74HC595 cuyas salidas Q0-6 y Q7 se conectan a las entradas de pantalla A-F y DP respectivamente.

Code

#define NUM_OF_DIGITS 4

int latch = 4; //74HC595  pin 9 STCP
int cs = 5; //74HC595  pin 10 SHCP
int data = 3; //74HC595  pin 8 DS
int dPins[4] = {11, 10, 9, 8};

//  DP G F E D C B A
//0: 1 1 0 0 0 0 0 0 0xc0
//1: 1 1 1 1 1 0 0 1 0xf9
//2: 1 0 1 0 0 1 0 0 0xa4
//3: 1 0 1 1 0 0 0 0 0xb0
//4: 1 0 0 1 1 0 0 1 0x99
//5: 1 0 0 1 0 0 1 0 0x92
//6: 1 0 0 0 0 0 1 0 0x82
//7: 1 1 1 1 1 0 0 0 0xf8
//8: 1 0 0 0 0 0 0 0 0x80
//9: 1 0 0 1 0 0 0 0 0x90
unsigned char table[] =
{0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};

void setup() {
  Serial.begin(115200);
  pinMode(latch, OUTPUT);
  pinMode(cs, OUTPUT);
  pinMode(data, OUTPUT);
  for (int j = 0; j < NUM_OF_DIGITS; j++) pinMode(dPins[j], OUTPUT);
}

void loop() {
  //Count from 0 to 9 on each digit
  for (int i = 0; i < NUM_OF_DIGITS; i++) {
    for (int j = 0; j < 10; j++) {
      Display(i, j);
      delay(500);
      Serial.println(j);
    }
    delay(500);
  }
}

void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

Una vez cargado el código, la pantalla debe contar de 0 a 9 en cada dígito.

Bonificación: pantalla de 4 dígitos

Para mostrar un número a 4 dígitos, convertiremos el número a 4 dígitos de base 10 utilizando las siguientes instrucciones:

      number = k;
      for (int i = 0; i < NUM_OF_DIGITS; i++)
      {
        digit_data[i] = number % 10;
        number /= 10;
      }

También utilizaremos la función millis() para asegurarnos de que la pantalla se actualiza correctamente.

#define NUM_OF_DIGITS 4

int latch = 4; //74HC595  pin 9 STCP
int cs = 5; //74HC595  pin 10 SHCP
int data = 3; //74HC595  pin 8 DS

int dPins[4] = {11, 10, 9, 8};

//  DP G F E D C B A
//0: 1 1 0 0 0 0 0 0 0xc0
//1: 1 1 1 1 1 0 0 1 0xf9
//2: 1 0 1 0 0 1 0 0 0xa4
//3: 1 0 1 1 0 0 0 0 0xb0
//4: 1 0 0 1 1 0 0 1 0x99
//5: 1 0 0 1 0 0 1 0 0x92
//6: 1 0 0 0 0 0 1 0 0x82
//7: 1 1 1 1 1 0 0 0 0xf8
//8: 1 0 0 0 0 0 0 0 0x80
//9: 1 0 0 1 0 0 0 0 0x90
unsigned char table[] =
{0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};


int digit_data[NUM_OF_DIGITS] = {0};

unsigned int number = 0;
unsigned long previousUpdate = 0, updateTime = 200;

void setup() {
  Serial.begin(115200);
  pinMode(latch, OUTPUT);
  pinMode(cs, OUTPUT);
  pinMode(data, OUTPUT);

  for (int j = 0; j < NUM_OF_DIGITS; j++) pinMode(dPins[j], OUTPUT);
}

void loop() {
  //Count from 0 to 999 on each digit
  unsigned int k = 0;
  while (k < 1000) {
    updateDigits();
    if (millis() - previousUpdate > updateTime) {
      k++;
      previousUpdate = millis();
      number = k;
      Serial.print(k); Serial.print(" (");
      for (int i = 0; i < NUM_OF_DIGITS; i++)
      {
        digit_data[i] = number % 10;
        number /= 10;
        Serial.print(digit_data[i]);
      }
      Serial.println(")");
    }
  }
}

void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

void updateDigits() {
  for (int j = 0; j < NUM_OF_DIGITS; j++)
  {
    Display(j, digit_data[j]);
    delay(5);
  }
}

El número debe incrementarse cada 200 milisegundos y mostrarse en los 4 dígitos.

Fuentes

• Uso de un registro de desplazamiento