[INeverCry CC By-SA Wikimedia Commons]

[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.

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 from CrocodileClips]

• Á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.

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]

Programas

Imos controlar o display 7 segmentos de dúas maneiras. Primeiro conectando directamente todos os seus pins ao Arduíno e utilizando un array (variable multidimensional), 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 do noso proxecto. Utiliza o que mellor che conveña para o teu proxecto.

1. Con arrays

[tecnoloxia.org CC By-SA from Fritzing]

1. Con arrays: 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, pero para mellor funcionamento deberiamos conectar unha resistencia por LED do display.

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

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.

Arduino

// 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<8 ; 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); }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// 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<8 ; 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:

Arduino

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

1 2 3 4 5 6 7 8

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

[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, por exemplo, con só tres pins de Arduíno podemos controlar 8 saídas dixitais.

[tecnoloxia.org CC By-SA]

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, 11 e 12:

• DATA IN ou DS: pin para enviar los bits en serie
• Clock ou SH_CP: indica cando hai que ler o bit.
• 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 reciba novos datos.

Arduino

/// Declaración de variables: int latchPin = 8 ; //Pin 8 conectado ao ST_CP do 74HC595 - Escritura nos pins de saída int clockPin = 12; //Pin 12 conectado ao SH_CP do 74HC595 - Clock int dataPin = 11; //Pin 11 connected ao DS do 74HC595 - Serve para enviar os datos byte dixito[] ={ B00000010, // escribe 0 B10011110, // escribe 1 B00100100, // escribe 2 B00001100, // escribe 3 B10011000, // escribe 4 B01001000, // escribe 5 B01000000, // escribe 6 B00011110, // escribe 7 B00000000, // escribe 8 B00011000, // 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); } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

/// Declaración de variables:   int latchPin = 8 ;          //Pin 8 conectado ao ST_CP do 74HC595 - Escritura nos pins de saída int clockPin = 12;        //Pin 12 conectado ao SH_CP do 74HC595 - Clock int dataPin = 11;         //Pin 11 connected ao DS do 74HC595 - Serve para enviar os datos   byte dixito[] ={                                      B00000010,    // escribe 0      B10011110,    // escribe 1    B00100100,    // escribe 2      B00001100,    // escribe 3      B10011000,    // escribe 4      B01001000,    // escribe 5      B01000000,    // escribe 6      B00011110,    // escribe 7      B00000000,    // escribe 8      B00011000,    // 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.