8. Pantalla de 7 segments

Display de 7 segmentos y 4 dígitos. Vista superior.

Els pendents

  • Escriviu un número a la pantalla de 7 segments.
  • Escriviu caràcters alfanumèrics a la pantalla 7 -segment.

Pantalla de 7 segments

La pantalla o la pantalla de set segments és un element que permet mostrar números i també símbols i caràcters de manera limitada. Aquest tipus de visualització s’utilitza en les ocasions en què es desitja una bona visibilitat i té l’avantatge de ser robust i fàcil de manejar. 7 Visualitzadors de segments es poden trobar normalment en plaques de hob, carregadors de bateries, reproductors d'àudio, forns de microones, rentadores, rellotges, etc.

En aquest tipus de visualització només heu de definir l'estat de set elements per formar la figura o la lletra desitjades. En un altre tipus de pantalles més complexes, cal definir l’estat de 35 o més punts per formar un nombre o un caràcter. El desavantatge de la visualització de 7 -segments es basa en la seva poca capacitat per representar lletres i símbols.

A la figura adjunta podeu veure una pantalla de 7 segments i la nomenclatura dels seus elements.

Segmentos del display de siete segmentos.

La funció: cpp: func: disnum

dispNum(int number)

L’argument de la funció: CPP: FUN: DISPNUM és un nombre enter positiu (0, 1, 2, ... 32767). Aquest número es mostrarà amb quatre dígits a la pantalla. Si el nombre té menys de quatre dígits, la pantalla apaga els dígits no utilitzats a l'esquerra. Si el nombre és superior a 9999, només es representen els quatre dígits de la dreta.

Aquests són alguns exemples de visualització.

dispNum(0);      ->  [       0 ]
dispNum(1);      ->  [       1 ]
dispNum(20);     ->  [     2 0 ]
dispNum(124);    ->  [   1 2 4 ]
dispNum(2345);   ->  [ 2 3 4 5 ]
dispNum(10321);  ->  [ 0 3 2 1 ]

L’exemple que apareix a continuació representa a la pantalla un nombre que augmenta i disminueix amb el botó 3 i 4.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Muestra un número en el display que disminuye o aumenta
// Presionando los pulsadores 3 y 4

#include <Wire.h>
#include <PC42.h>

int num;

void setup() {
   pc.begin();    // Inicializar el módulo PC42
   num = 100;     // Valor inicial a representar
}

void loop() {
   
   // Actualiza el valor del número a representar
   num = num + pc.keyCount(KEY_UP);
   num = num - pc.keyCount(KEY_DOWN);
   if (num < 0) num = num + 1000;
   if (num >= 1000) num = num - 1000;

   // Representa el número en el display
   pc.dispNum(num);
}

La funció: cpp: func: `disputa 'amb dos arguments

La funció: CPP: Fun: Dispute permet escriure números i caràcters als set segments i quatre figures visualitzadores. Segons el nombre d’arguments, la funció es comportarà d’una altra manera.

dispWrite(int position, int segments)

Quan els arguments de la funció: CPP: Fun: `Dispute 'són dos números, el primer representa la posició del dígit que voleu canviar i el segon representa els segments que voleu activar. Les posicions dels dígits són, d’esquerra a dreta, 1 2 3 4.

Els segments d’un dígit s’encenen o s’apaguen amb un número binari que representa cadascun d’ells. El primer dígit binari (més a la dreta) representa el segment 'A'. El segon dígit binari representa el segment "B" i així successivament al vuitè dígit binari que no representa cap segment.

Per exemple, el número binari 0B00000001 activarà el segment 'A' i es veurà a la pantalla de 7 segments com una barra superior '¯'. El número binari 0B00000110 activarà els segments 'B' i 'C' i es veurà a la visualització de 7 segments com el número 1. El número binari 0B010000 activarà el segment 'G' i es veurà a la visualització de 7 segments com el menys signe '-'.

De vegades serà més fàcil utilitzar els valors ja predefinits a la llibreria. A continuació, es mostra una llista amb els valors predefinits de la norma.

  • ** Números: ** DD_0, DD_1, DD_2, DD_3, DD_4, DD_5, DD_6, DD_7, DD_8, DD_9
  • ** Lletres: ** dd_a, dd_b, dd_b, dd_c, dd_d, dd_e, dd_f, dd_g, dd_g, dd_h, dd_h, dd_i, dd_i, dd_j, dd_k, dd_l, dd_n, dd_ny, dd_o, dd_o, dd_o dd_r, Dd_s, dd_t, dd_u, dd_u, dd_y, dd_y, dd_z
  • ** Espai blanc: ** dd_sp

També podeu crear símbols personalitzats amb números binaris.

El següent programa gira una barra a través dels quatre segments superiors d’un dígit.

 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
// Gira un segmento alrededor de los cuatro ledes superiores de un dígito

#include <Wire.h>
#include <PC42.h>

void setup() {
   pc.begin();  // Inicializar el módulo PC42
}

void loop() {
   // Enciende el segmento 'a' y espera 0.1 segundos
   pc.dispWrite(1,  0b00000001);
   delay(100);

   // Enciende el segmento 'b' y espera 0.1 segundos
   pc.dispWrite(1, 0b00000010);
   delay(100);

   // Enciende el segmento 'g' y espera 0.1 segundos
   pc.dispWrite(1, 0b01000000);
   delay(100);

   // Enciende el segmento 'f' y espera 0.1 segundos
   pc.dispWrite(1, 0b00100000);
   delay(100);
}

El següent programa gira una barra a través de tots els segments exteriors d’un dígit.

 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
// Gira un segmento alrededor de los 6 segmentos exteriores
// del primer dígito del display.

#include <Wire.h>
#include <PC42.h>

int segment;

void setup() {
   pc.begin();            // Inicializar el módulo PC42
   segment = 0b00000001;  // El primer segmento encendido es el 'a'
}

void loop() {

   // Enciende el segmento seleccionado y espera 0.100 segundos
   pc.dispWrite(1, segment);
   delay(100);

   // Desplaza el segmento hacia uno mayor
   segment = (segment << 1);

   // Si se ha llegado al segmento 'g'
   if (segment == 0b01000000)
      // Enciende de nuevo el segmento 'a'
      segment = 0b00000001;
}

La funció: cpp: func: `disputa 'amb quatre arguments

dispWrite(int digit, int digit, int digit, int digit)

Quan la funció: CPP: Fun: `Dispute 'té quatre arguments, cadascun s'interpreta com el valor de cada dígit del visualitzador de set segments. Aquesta és la funció més senzilla per visualitzar una paraula a la pantalla.

El següent programa d’exemple fa que aparegui la paraula “hola” a la pantalla.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// Muestra la palabra 'HOLA' en el display

#include <Wire.h>
#include <PC42.h>

void setup() {

   // Inicializar el módulo PC42
   pc.begin();

   // Muestra la palabra 'HOLA'
   pc.dispWrite(DD_H, DD_O, DD_L, DD_A);

}

void loop() {
}

Exercicis

Programa el codi necessari per resoldre els problemes següents.

  1. Completeu el programa següent per informar -se de 10 a 0 canviant el valor una vegada cada segon. Un cop finalitzat el compte enrere, el LED vermell s’ha d’encendre.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
    // Cuenta atrás de 10 segundos

#include <Wire.h>
#include <PC42.h>

int count;

void setup() {
   pc.begin();         // Inicializar el módulo PC42
   count = 10;
   while(count > 0) {
                        // Muestra el número en el display
                        // Espera un segundo
                        // Reduce la variable count en una unidad
   }
                        // Muestra el número en el display
                        // Enciende el led rojo
}

void loop() {
}

  2. Completa el programa següent per funcionar com a daus electrònic. Quan premeu el botó 1, s'ha de mostrar un número a la pantalla de l'1 al 6.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    // Dado electrónico

#include <Wire.h>
#include <PC42.h>

void setup() {
   pc.begin();       // Inicializar el módulo PC42
}

void loop() {
   int dado;
   // Calcula un número aleatorio entre 1 y 6
   dado = random(1, 1 + 6);
                          // Muestra el valor por el display
                          // Espera 50 milisegundos
                          // Espera mientras no se presione la tecla 1
}

  3. Mostra les paraules "Jose" i "Lulu" a la pantalla, canviant d'un a un altre cada segon

  4. Mostra al quart dígit una animació que consisteix a il·luminar tots els segments un per un des del segment 'A' al segment 'f'. Quan tots els segments s’il·luminen, tothom s’ha d’apagar de nou i la seqüència tornarà a començar. El temps d’espera entre l’encesa d’un segment i el següent serà mig segon.

  5. Dissenyeu dos nous símbols i realitzeu un programa que els mostri a la pantalla a les posicions 2 i 4.

  6. Dibuixa uns pesos a la pantalla.

  7. Mostra les paraules "hola" a la pantalla i un nom curt. Les dues paraules han d’alternar cada mig segon.

  8. Feu una animació original a la pantalla, mostrant símbols o moviments de llum.