Display 7 segmentos

191px-seven_segment_display-animated
[INeverCry CC By-SA Wikimedia Commons]
317px-seven_segment_02_pengo
[Peter Halasz CC By-SA Wikimedia Commons]

Descrición:

Un display ou visualizador de 7 segmentos é un compoñente electrónico que se utiliza para representar números. O display está composto por 7 LEDs, os cales se acenden ou apagan en función do número a representar.

O máis cómodo e fácil para incorporar a un proxecto sería utilizar un módulo 4-digit Display ou DigitalTube, que podedes atopar nesta páxina. Pero usar un display 7-seg máis un rexistro de desprazamento é unha práctica para entender como funcionan estes dispositivos, así que non descartamos esta opción.

Montaxe:

Poden ser de ánodo común ou cátodo común. Isto é que o pin común pódese conectar a Vcc ou a GND respectivamente.

[tecnoloxia.org CC By-SA]
  • Ánodo común: Os pins comúns debemos conectalos a Vcc cunha resistencia de protección, por exemplo, de 330Ω. Cada LED actívase cun 1 e desactívase cun 0.
  • Cátodo común: Os pins comúns debemos conectalos a GND cunha resistencia de protección, por exemplo, de 330Ω. Cada LED actívase cun 0 e desactívase cun 1.

Para ter sempre a mesma intensidade circulando por cada LED deberiamos conectar unha resistencia de protección en cada un deles, pero por simplificar o circuíto utilizo unha única resistencia no pin común. Chega para protexer o display e a diferencia de luminosidade non é perceptible.

Na seguinte táboa podemos ver que pins teñen que estar activos para acender cada un dos números. Non inclúo o punto, que deixaremos desconectado, pois cun díxito non imos traballar con decimais.

[tecnoloxia.org CC By-SA]
decimal BCD Cátodo común Ánodo común
A B C D a b c d e f g a b c d e f g
0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1
1 0 0 0 1 0 1 1 0 0 0 0 1 0 0 1 1 1 1
2 0 0 1 0 1 1 0 1 1 0 1 0 0 1 0 0 1 0
3 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0 1 1 0
4 0 1 0 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0
5 0 1 0 1 1 0 1 1 0 1 1 0 1 0 0 1 0 0
6 0 1 1 0 1 0 1 1 1 1 1 0 1 0 0 0 0 0
7 0 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 1
8 1 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0
9 1 0 0 1 1 1 1 1 0 1 1 0 0 0 0 1 0 0
Apagado 1 0 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1

 

Imos controlar o display 7 segmentos de dúas maneiras. Primeiro conectando directamente todos os seus pins ao Arduíno e despois utilizando un rexistro de desprazamento ou Shift Register, o que nos permite aforrar pins de Arduíno para telos dispoñibles para outros compoñentes. Utiliza o que mellor che conveña para o teu proxecto.

1. Conexión directa

1. Conexión directa: Un display 7-segmentos de ánodo común conectariámolo do seguinte xeito cunha placa Arduíno. Por simplificar utilízase unha única resistencia de protección.

Se fose de cátodo común deberiamos conectar os pins comúns a GND.

7seg_anodocomun_fritzing
[tecnoloxia.org CC By-SA from Fritzing]

2. Con Shift Register

shiftregister
[tecnoloxia.org CC By-SA]
2. Con Shift Register: Un rexistro de desprazamento é un circuíto secuencial que cumpre as seguintes funcións:

  • É capaz de almacenar un conxunto de n bits.
  • Permite realizar a conversión de datos de serie a paralelo e viceversa.

Nós imos utilizar o 74HC595 (Shift Register de 8 bits serial-in, parallel-out) para cargar datos en serie e que o rexistro os vaia cargando nas saídas en paralelo. Con isto aforramos pins do Arduíno pois con só tres pins podemos controlar 8 saídas dixitais.

A forma de conectalo é a que se mostra na figura.

Hai tres pins importantes que conectaremos á placa Arduíno, no noso caso aos pins 8, 9 e 10:

  • DATA IN ou DS: pin para enviar los bits en serie
  • LATCH ou ST_CP: Cando os 8 bits de entrada se leron no rexistro, o LATCH escribe estes bits nos pins de saída do chip e mantenos ata que se reciban novos datos.
  • Clock ou SH_CP: marca cando hai que ler cada bit.

Programas

1. Conexión directa

1. Conexión directa: Para enviar o díxito que queremos escribir no display creamos un array de m filas e n columnas:
tipo nome[m][n]={ táboa };

Cada fila corresponde a un díxito, e cada valor 0 e 1 aos valores que teñen que tomar as saídas dixitais a, b, c, d , e, f, g para un display.

O array deste exemplo é para un display 7-seg de ánodo común. No caso de que utilices un de cátodo común debes intercambiar os ceros e uns.

// Declaración de variables:

/* Creamos un array de dúas dimensións de 11 filas e 7 columnas. 
Cada fila corresponde a un díxito, e cada valor 0 e 1 aos valores que teñen que tomar as saídas dixitais a, b, c, d , e f, g para un display de ánodo común. 
Usamos byte (8 bits) e non int(16 bits), para aforrar memoria.

Este array é para un display 7-seg de ánodo común. 
No caso de que utilices un de cátodo común debes intercambiar os ceros e uns. */

byte dixito[11][7] = {    
  { 0,0,0,0,0,0,1 },      // escribe 0 
  { 1,0,0,1,1,1,1 },      // escribe 1 
  { 0,0,1,0,0,1,0 },      // escribe 2 
  { 0,0,0,0,1,1,0 },      // escribe 3 
  { 1,0,0,1,1,0,0 },      // escribe 4 
  { 0,1,0,0,1,0,0 },      // escribe 5 
  { 0,1,0,0,0,0,0 },      // escribe 6 
  { 0,0,0,1,1,1,1 },      // escribe 7 
  { 0,0,0,0,0,0,0 },      // escribe 8 
  { 0,0,0,1,1,0,0 },      // escribe 9
  { 1,1,1,1,1,1,1 }       // apagado  
} ;

// Configuración: 
            
void setup() {
  for (int n=7;n<=13;n++) {        // configuramos os pins do 7 ata o 13 como saídas
    pinMode(n, OUTPUT);       
  } 
}

// Programa:  

/* Creamos unha función que busca na táboa o valor N.  
A función for i vai lendo os elementos do array para escribilos no pin correspondiente de saída, 
que o calculamos como i+7, pois usamos os pins do 7 ao 13 para conectar os elementos do display */

void Display(int N) {
  for (int i= 0 ; i<7 ; i++) {
    digitalWrite(i+7 , dixito[N][i]);
  }
}

void loop() {
  Display(1);   // Chama á función Display para que escriba os díxitos que queiramos
  delay(1000);
  Display(2);
  delay(1000);
 }

Se queremos que vaia mostrando os díxitos dun en un , substituímos a función loop anterior por esta:
void loop() {
  for ( int k=0 ; k<10 ; k++) {       // Chama á función Display para que escriba os díxitos de 0 a 9
    Display(k);
    delay(1000);
  }
}

2. Con Shift Register

2. Con Shift Register: Debemos indicar cales son os pins aos que está conectado o rexistro de desprazamento e crear un array “dixito[]” cos bytes que queremos mostrar en binario (poñemos un B diante, por exemplo B10011110).

Para enviar os datos poñemos o latch a LOW, cargamos os datos mediante a función
shiftOut(dataPin, clockPin, LSBFIRST, dixito[numero]);
e enviamos os datos poñendo Latch a HIGH.

/// Declaración de variables: 

int dataPin = 8;         // Pin 8 conectado ao DS do 74HC595 - Serve para enviar os datos
int latchPin = 9 ;       // Pin 9 conectado ao ST_CP do 74HC595 - Escritura nos pins de saída
int clockPin = 10;       // Pin 10 conectado ao SH_CP do 74HC595 - Clock

byte dixito[] ={          // díxitos para un display 7 seg de ánodo común (abcdefgdot)                        
   B00000011,    // escribe 0   
   B10011111,    // escribe 1 
   B00100101,    // escribe 2  
   B00001101,    // escribe 3  
   B10011001,    // escribe 4  
   B01001001,    // escribe 5  
   B01000001,    // escribe 6  
   B00011111,    // escribe 7  
   B00000001,    // escribe 8  
   B00011001,    // escribe 9  
   B11111111     // apagado
};

// Configuración:

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

// Programa:  

void Display(byte numero){ 
  digitalWrite(latchPin, LOW); 
  shiftOut(dataPin, clockPin, LSBFIRST, dixito[numero]); // función para enviar os datos en serie 
  digitalWrite(latchPin, HIGH); 
}

void loop(){                // Imos mostrando os díxitos dun en un.
  for(int n=0;n<11;n++){
    Display(n);
    delay(1000);
  }
}

Propostas:

  1. Display descendente. Fai que se vaian amosando os díxitos de forma descendente, desde o 9 ata o 0.
  2. Conta atrás. Prememos nun pulsador para iniciar unha conta atrás na que se van amosando os díxitos de forma descendente, desde o 5 ata o 0. Ao chegar a 0 soa unha melodía cun zumbador.
  3. Contador. Fai que cada vez que premamos un pulsador sume un díxito a un contador, e que este se mostre nun display. Pon un límite de ata 9, e que a partir de entón se poña de novo a 0.
  4. Contar e descontar. Fai que cada vez que premamos un pulsador sume un díxito a un contador, e que este se mostre nun display. Outro pulsador fai que se desconten os números. Pon un límite superior de 9 e un límite inferior de 0.
  5. Que pulsador? Conecta dous pulsadores e fai que cada vez que prememos nun deles indique na pantalla cal dos pulsadores foi pulsado primeiro, o 1 ou o 2.

Deixa un comentario