fbpixel
Etiquetas: ,
5
(1)

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

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

¿De cuánta utilidad te ha parecido este contenido?

¡Haz clic en una estrella para puntuarlo!

Promedio de puntuación 5 / 5. Recuento de votos: 1

Hasta ahora, ¡no hay votos!. Sé el primero en puntuar este contenido.

Ya que has encontrado útil este contenido...

¡Sígueme en los medios sociales!

¡Siento que este contenido no te haya sido útil!

¡Déjame mejorar este contenido!

Dime, ¿cómo puedo mejorar este contenido?