Display 7 segmentos

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.

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.

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: 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);
  }
}