Matriz de leds

[By Laserlicht CC BY-SA from Wikimedia Commons]
[By Laserlicht CC BY-SA from Wikimedia ]
matrizleds1
[By oomlout CC BY-SA from Wikimedia Commons]

Descrición:

Nesta sección imos traballar cunha matriz de LEDs, que non é máis ca un conxunto de LEDs dispostos en forma de táboa ou matriz, cunha serie de filas e columnas. Nestas matrices podemos debuxar letras, símbolos e debuxos de todo tipo, polo que poden ter moitas aplicacións para os nosos proxectos.

Hainas con LEDs dunha única cor, de dúas cores e con LEDs RGB. Nós imos usar unha matriz sinxela dunha única cor e de rango 8×8.

O maior problema que atopamos a priori nestas matrices de LEDs é a cantidade de pins que teñen, o que nos limitaría moito a realización de proxectos, pois consumiriamos todos os pins do noso Arduíno para facelas funcionar e non nos quedarían suficientes para facer outras cousas.

Nós imos usar aquí unha solución máis práctica, que é a de utilizar un circuíto integrado para gobernar a matriz: MAX7219, co cal aforraremos pins do Arduíno. Pódese mercar a matriz co circuíto integrado xa soldado ou os compoñentes por separado. Para traballar en secundaria recomendo a primeira opción.

ledmatrix_schem
[Pins dunha matriz de LEDs from arduino.cc]
ledmatrixmax7219
[Matriz con MAX7219 By BIGDOG1971 CC from Instructables]

Conexión:

[tecnoloxia.org CC By-SA]
Imos conectar directamente ao Arduíno a Matriz con MAX7219.

A conexión do integrado realízase a través dun porto serie asíncrono SPI. No caso dun Arduíno UNO conectaremos:

  • dataPin: DIN (MISO) ou SDI ao pin 12
  • clockPin: CLK  ou SCL ao pin 11
  • csPin: CS ao pin 10

dataPin (o pin DIN ou SDI da matriz) é o encargado de enviar os datos en serie.

clockPin (pin CLK ou SCL na matriz) é o encargado de emitir o sinal de reloxo que indica cando hai que ler cada bit.

csPin (o pin CS da matriz) é o pin de selección de dispositivo.

 

Hai varias librerías que podemos utilizar para o control dunha matriz de leds. Nesta páxina presentamos 2 opcións: LedControlMs para traballar cunha única matriz e MaxMatrix se queremos encadear varias matrices.

Librería LedControlMS e configuración:

Aquí imos mostrar unha serie de programas nos que podes ver as distintas posibilidades da Matriz de LEDs. Estes programas deberás adaptalos segundo as necesidades do teu proxecto.

Para facer os nosos programas na matriz imos utilizar unha librería proporcionada por Adafruit chamada LedControlMS (ligazón a GitHub. Ligazón directa ao ficheiro zip) Nela temos toda a programación necesaria para definir os caracteres na matriz, polo que aforramos moito traballo de programación.

Descargámola ao noso ordenador e desde o IDE seleccionamos Sketch → Incluír biblioteca → Engadir .zip

libreria

Todos os programas empezarán co seguinte código no que preparamos a matriz.

#include <LedControlMS.h>

//  LedControl(int dataPin, int clkPin, int csPin, int numDevices=1);
//  No noso caso: dataPin=12, clkPin=11, csPin=10, 1 matriz

LedControl lc=LedControl(12,11,10,1);   // Instancia de LedControl

// Configuración:
// Como só temos conectada unha matriz, esta é 0. As seguintes serían 1, 2, etc.

void setup(){
  lc.shutdown(0,false);    // Activamos a matriz 
  lc.setIntensity(0,8);    // Asignamos ao brillo un valor intermedio (entre 0 e 15)
  lc.clearDisplay(0);      // Borramos 
}

Prácticas:

Nas vindeiras prácticas indicaremos unicamente o código do programa que hai que engadir ao anterior. Lémbrate de incluír a primeira parte do programa!

1. Texto

Imos escribir un texto no noso programa e vaise mostrar, carácter a carácter, na matriz de LEDs. Para iso utilizamos a función:   lc.writeString (0,”texto a escribir”);

// Programa:

void loop() {
  
  lc.writeString(0,"tecnoloxia.org");
  delay(1000);
  lc.writeString(0,"1234567890");
  delay(1000);
  
}

 

Se o que desexamos é que se mostre na matriz un texto recollido desde a consola utilizaremos o seguinte programa, que recolle cada carácter introducido no buffer. Para mostralo usamos a función: lc.displayChar (0,carácter a escribir);

Lémbrate de incluír no setup() a instrución Serial.begin(9600); para que se estableza a comunicación serie co ordenador.

void loop() {

  while (Serial.available() > 0) {                   // mentres haxa datos no buffer facemos o seguinte:
    byte c = Serial.read();                          // Lemos un carácter
    lc.displayChar(0, lc.getCharArrayPosition(c));   // escribímolo na matriz
    delay(500);
  }
  lc.clearAll();
  
}

2. Scroll

Se o que queremos é que as letras se movan pola pantalla dun lado a outro (scroll) debemos utilizar unhas funcións que posibilitan ese desprazamento. O primeiro parámetro indica o carácter a desprazar e o segundo o intervalo de tempo entre as escrituras na pantalla, que inflúe na velocidade de desprazamento.

  • Scroll cara á esquerda: scrollLeft(carácter, tempo);
  • Scroll cara á dereita: scrollRight(carácter, tempo);

// Programa:

// Primeiro definimos as funcións de scroll

// Función scroll cara á esquerda

void scrollLeft(char ch, int tempo){                   
  int pos =lc.getCharArrayPosition(ch);  
  for (int scroll=0; scroll<13; scroll++) {           // Scroll de 0 a 13 pois o ancho da letra é de 5 columnas
     for (int i=7;i<13;i++){                          // Escribe cada letra desde a posición marcada
        lc.setRow(0,i-scroll,alphabetBitmap[pos][i-7]);
     }
  delay(tempo);
  lc.clearDisplay(0);
  }
}
 
// Función scroll cara á dereita

void scrollRight(char ch, int tempo){
  int pos =lc.getCharArrayPosition(ch);
  for (int scroll=0; scroll<13; scroll++) {
     for (int i=0; i<6;i++) {
        lc.setRow(0, scroll+i-5, alphabetBitmap[pos][i]);
    } 
    delay(tempo);
    lc.clearDisplay(0);
  }
}

// No loop indicamos os textos que queremos mostrar con scroll chamando ás anteriores funcións

void loop() {
  
// Scroll dun carácter
 
  scrollLeft('a', 200);
  delay(500);
  scrollRight('a', 100);
  delay(500);
 
// Scroll dun texto (debemos ir collendo os caracteres un a un)  
 
  String palabra="tecno";
  for (int n=0; n<palabra.length();n++){
    char c = palabra.charAt(n) ;
    scrollLeft(c, 150);
  }
 
// Scroll dun texto introducido a través da consola
 
  Serial.print ("introduce un texto na consola");
  while(Serial.available()==0);
  while (Serial.available() > 0) {   
    byte c = Serial.read();
    scrollLeft(c, 150);
  }
  lc.clearAll();
 
}

3. Un LED

Neste primeiro programa imos acender e apagar algúns LEDs indicando as súas coordenadas. Para iso utilizamos a función lc.setLed(matriz, fila, columna, estado).

Por exemplo:  lc.setLed(0,5,5,HIGH); // Acender o LED da posición (5, 5)

Para borrar toda a pantalla utilizamos a función:   lc.clearDisplay(0);

// Programa:
  
void loop() { 

  // void setLed(int addr, int row, int col, boolean state);
  // lc.setLed(matriz, fila, columna, estado)
  
  lc.setLed(0,0,0,HIGH);  // Acendemos o LED (0,0)
  delay(500);
  lc.setLed(0,0,7,HIGH);  // Acendemos o LED (0,7)
  delay(500);
  lc.setLed(0,7,0,HIGH);
  delay(500);
  lc.setLed(0,7,7,HIGH);
  delay(500);
  lc.setLed(0,0,0,LOW);
  delay(200);
  lc.setLed(0,0,7,LOW);
  delay(200);
  lc.setLed(0,7,0,LOW);
  delay(200);
  lc.setLed(0,7,7,LOW);
  delay(200);  

}

 

Tamén podemos ir movéndonos pola matriz:

// programa

void loop() {
  
  for (int i=0; i<8; i++){        // Desprazamento na fila 2
    lc.setLed(0,2,i,HIGH);
    delay(100);
    lc.setLed(0,2,i,LOW);
  }
  delay(100);

  for (int i=0; i<8; i++){        // Desprazamento na columna 2
    lc.setLed(0,i,2,HIGH);
    delay(100);
    lc.setLed(0,i,2,LOW);
  }
  delay(100);

  for (int i=0; i<8; i++){        // Desprazamento continuo 
    for (int j=0; j<8; j++){
      lc.setLed(0,i,j,HIGH);
      delay(100);
      lc.setLed(0,i,j,LOW);
    }
    delay(100);
  }
  delay(1000);

}

4. Filas e columnas

No caso anterior desprazamos un único bit. Se queremos desprazar un byte (conxunto de 8 bits) dun lado a outro utilizaremos as seguintes funcións:

  • Control das filas: lc.setRow(matriz, fila, valor)
  • Control das columnas:  lc.setColumn(matriz, columna, valor);
  • Borrar matriz:   lc.clearDisplay(0);

Podemos utilizar o valor en binario: Por exemplo con B10100101 (en binario) indicamos os LEDs que están acesos cun 1 e os apagados cun 0. Tamén podemos expresar o byte en decimal (0= todo apagado ata 255 todo aceso) ou en hexadecimal (0x00 todo apagado ata 0xFF todo aceso)

// Programa: 

void loop() {
  
  for (int i=0; i<8; i++){        // Desprazamento vertical dun byte    
    lc.setColumn(0,i,B10100101);
    delay(100);
    lc.setColumn(0,i,LOW);
  }
  lc.clearDisplay(0);             
  delay(1000);


  for (int i=0; i<8; i++){        // Desprazamento horizontal dun byte    
    lc.setRow(0,i,B01011010);
    delay(100);
    lc.setRow(0,i,LOW);
  }
  lc.clearDisplay(0);
  delay(1000);


  for (int i=0; i<8; i++){        // Varrido continuo columnas
    lc.setColumn(0,i,255); 
    delay(100);
  }
  lc.clearDisplay(0);
  delay(1000);


  for (int i=0; i<8; i++){      // Varrido de filas unha a unha
    lc.setRow(0,i,255); 
    delay(100);
    lc.setRow(0,i,0); 
  }
  lc.clearDisplay(0);
  delay(1000);

}

5. Mov. lateral

Imos desprazar un byte cara á esquerda e cara á dereita utilizando o operador de desprazamento lóxico

  • <<  Despraza  cara á esquerda (multiplica por 2)
  • >> Despraza cara á dereita (divide entre 2)

// Programa: 

void loop() {

  int valor2=B11100000;           
  for (int i=0; i<8; i++){       
    lc.setColumn(0,2,valor2);
    valor2=valor2>>1;           // Despraza os bits á dereita na columna 2 un a un
    delay(200);
  }
  lc.clearDisplay(0);
  delay(1000);


  int valor3=B00000111;           
  for (int i=0; i<8; i++){       
    lc.setColumn(0,2,valor3);
    valor3=valor3<<1;           // Despraza os bits á esquerda na columna 2 un a un
    delay(200);
  }
  lc.clearDisplay(0);
  delay(1000);

}

6. Debuxos

Outra cousa que nos pode interesar é crear debuxos para mostrar na matriz. Para iso temos que definir cada debuxo cun array que conteña os valores dos LEDs (acesos e apagados). Existen aplicacións para facelo facilmente,  como a que hai nesta ligazón ou nesta (aquí podes rotar os debuxos). Só hai que seleccionar os LEDs que queremos acender e xera automaticamente os valores en binario e hexadecimal. Revisa a orientación que deben ter os debuxos segundo a orientación da túa matriz de LEDs.

matriz_debuxo
[Captura da aplicación led matrix generator]
Neste exemplo imos facer o latexo dun corazón. Para facer outras animacións só tes que modificar os arrays cos teus debuxos, xerar o patrón como se indica e programar o void loop() segundo as túas necesidades.
//Código dos frames que imos mostrar:

byte corazon1[] = {   
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00011000};

byte corazon2[] = {
  B01100110,
  B10011001,
  B10000001,
  B10000001,
  B10000001,
  B01000010,
  B00100100,
  B00011000};

//Función para transformar o array do debuxo nun patrón para a matriz

void mostrar(String nome){
  for (int i= 0; i<8; i++){
    lc.setRow(0,i,nome[i]);
  }
}
void loop() {
  
  mostrar(corazon1);     // Mostra o corazón1
  delay(500); 
  mostrar(corazon2);     // Mostra o corazón2    
  delay(500); 
  
}

 

Librería MaxMatrix e configuración:

Coa librería anterior, para facer un scroll había que agardar a que unha letra saíse da pantalla para que aparecese a seguinte. Se unsamos unha única matriz de LEDs puede no tener importancia, pero se encadeamos varias matrices non queda ben. Con esta librería poderemos facer isto mellor. Se queres conectar en cascada varias materices só tes que ir unindo os pins OUT da primeira cos pins IN da seguinte, e así sucesivamente.

Descarga a librería MaxMatrix.zip e instálaa.

// Librerías:

#include <MaxMatrix.h>
#include <avr/pgmspace.h>

// Pins da conexión ao arduino

int data = 12;    // Pin DIN ou SDI 
int load = 10;    // Pin CS 
int clock = 11;   // Pin CLK ou SCL 

// Número de matrices que temos. Neste caso temos dúas conectadas en cascada

int maxuse = 2; 


// Definimos a matriz cos seus parámetros

MaxMatrix m(data, load, clock, maxuse); 
byte buffer[10];

// Texto que queremos mostrar

char texto1[] = "TECNO - abcde     ";

// Definimos os caracteres posibles a mostrar e almacenámolos na memoria do programa

PROGMEM const byte CAD[] = {
3, 8, B0000000, B0000000, B0000000, B0000000, B0000000, // space
1, 8, B1011111, B0000000, B0000000, B0000000, B0000000, // !
3, 8, B0000011, B0000000, B0000011, B0000000, B0000000, // "
5, 8, B0010100, B0111110, B0010100, B0111110, B0010100, // #
4, 8, B0100100, B1101010, B0101011, B0010010, B0000000, // $
5, 8, B1100011, B0010011, B0001000, B1100100, B1100011, // %
5, 8, B0110110, B1001001, B1010110, B0100000, B1010000, // &
1, 8, B0000011, B0000000, B0000000, B0000000, B0000000, // '
3, 8, B0011100, B0100010, B1000001, B0000000, B0000000, // (
3, 8, B1000001, B0100010, B0011100, B0000000, B0000000, // )
5, 8, B0101000, B0011000, B0001110, B0011000, B0101000, // *
5, 8, B0001000, B0001000, B0111110, B0001000, B0001000, // +
2, 8, B10110000, B1110000, B0000000, B0000000, B0000000, // ,
4, 8, B0001000, B0001000, B0001000, B0001000, B0000000, // -
2, 8, B1100000, B1100000, B0000000, B0000000, B0000000, // .
4, 8, B1100000, B0011000, B0000110, B0000001, B0000000, // /
4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // 0
3, 8, B1000010, B1111111, B1000000, B0000000, B0000000, // 1
4, 8, B1100010, B1010001, B1001001, B1000110, B0000000, // 2
4, 8, B0100010, B1000001, B1001001, B0110110, B0000000, // 3
4, 8, B0011000, B0010100, B0010010, B1111111, B0000000, // 4
4, 8, B0100111, B1000101, B1000101, B0111001, B0000000, // 5
4, 8, B0111110, B1001001, B1001001, B0110000, B0000000, // 6
4, 8, B1100001, B0010001, B0001001, B0000111, B0000000, // 7
4, 8, B0110110, B1001001, B1001001, B0110110, B0000000, // 8
4, 8, B0000110, B1001001, B1001001, B0111110, B0000000, // 9
2, 8, B01010000, B0000000, B0000000, B0000000, B0000000, // :
2, 8, B10000000, B01010000, B0000000, B0000000, B0000000, // ;
3, 8, B0010000, B0101000, B1000100, B0000000, B0000000, // < 3, 8, B0010100, B0010100, B0010100, B0000000, B0000000, // = 3, 8, B1000100, B0101000, B0010000, B0000000, B0000000, // >
4, 8, B0000010, B1011001, B0001001, B0000110, B0000000, // ?
5, 8, B0111110, B1001001, B1010101, B1011101, B0001110, // @
4, 8, B1111110, B0010001, B0010001, B1111110, B0000000, // A
4, 8, B1111111, B1001001, B1001001, B0110110, B0000000, // B
4, 8, B0111110, B1000001, B1000001, B0100010, B0000000, // C
4, 8, B1111111, B1000001, B1000001, B0111110, B0000000, // D
4, 8, B1111111, B1001001, B1001001, B1000001, B0000000, // E
4, 8, B1111111, B0001001, B0001001, B0000001, B0000000, // F
4, 8, B0111110, B1000001, B1001001, B1111010, B0000000, // G
4, 8, B1111111, B0001000, B0001000, B1111111, B0000000, // H
3, 8, B1000001, B1111111, B1000001, B0000000, B0000000, // I
4, 8, B0110000, B1000000, B1000001, B0111111, B0000000, // J
4, 8, B1111111, B0001000, B0010100, B1100011, B0000000, // K
4, 8, B1111111, B1000000, B1000000, B1000000, B0000000, // L
5, 8, B1111111, B0000010, B0001100, B0000010, B1111111, // M
5, 8, B1111111, B0000100, B0001000, B0010000, B1111111, // N
4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // O
4, 8, B1111111, B0001001, B0001001, B0000110, B0000000, // P
4, 8, B0111110, B1000001, B1000001, B10111110, B0000000, // Q
4, 8, B1111111, B0001001, B0001001, B1110110, B0000000, // R
4, 8, B1000110, B1001001, B1001001, B0110010, B0000000, // S
5, 8, B0000001, B0000001, B1111111, B0000001, B0000001, // T
4, 8, B0111111, B1000000, B1000000, B0111111, B0000000, // U
5, 8, B0001111, B0110000, B1000000, B0110000, B0001111, // V
5, 8, B0111111, B1000000, B0111000, B1000000, B0111111, // W
5, 8, B1100011, B0010100, B0001000, B0010100, B1100011, // X
5, 8, B0000111, B0001000, B1110000, B0001000, B0000111, // Y
4, 8, B1100001, B1010001, B1001001, B1000111, B0000000, // Z
2, 8, B1111111, B1000001, B0000000, B0000000, B0000000, // [
4, 8, B0000001, B0000110, B0011000, B1100000, B0000000, // backslash
2, 8, B1000001, B1111111, B0000000, B0000000, B0000000, // ]
3, 8, B0000010, B0000001, B0000010, B0000000, B0000000, // hat
4, 8, B1000000, B1000000, B1000000, B1000000, B0000000, // _
2, 8, B0000001, B0000010, B0000000, B0000000, B0000000, // `
4, 8, B0100000, B1010100, B1010100, B1111000, B0000000, // a
4, 8, B1111111, B1000100, B1000100, B0111000, B0000000, // b
4, 8, B0111000, B1000100, B1000100, B0101000, B0000000, // c
4, 8, B0111000, B1000100, B1000100, B1111111, B0000000, // d
4, 8, B0111000, B1010100, B1010100, B0011000, B0000000, // e
3, 8, B0000100, B1111110, B0000101, B0000000, B0000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B0000000, // g
4, 8, B1111111, B0000100, B0000100, B1111000, B0000000, // h
3, 8, B1000100, B1111101, B1000000, B0000000, B0000000, // i
4, 8, B1000000, B10000000, B10000100, B1111101, B0000000, // j
4, 8, B1111111, B0010000, B0101000, B1000100, B0000000, // k
3, 8, B1000001, B1111111, B1000000, B0000000, B0000000, // l
5, 8, B1111100, B0000100, B1111100, B0000100, B1111000, // m
4, 8, B1111100, B0000100, B0000100, B1111000, B0000000, // n
4, 8, B0111000, B1000100, B1000100, B0111000, B0000000, // o
4, 8, B11111100, B0100100, B0100100, B0011000, B0000000, // p
4, 8, B0011000, B0100100, B0100100, B11111100, B0000000, // q
4, 8, B1111100, B0001000, B0000100, B0000100, B0000000, // r
4, 8, B1001000, B1010100, B1010100, B0100100, B0000000, // s
3, 8, B0000100, B0111111, B1000100, B0000000, B0000000, // t
4, 8, B0111100, B1000000, B1000000, B1111100, B0000000, // u
5, 8, B0011100, B0100000, B1000000, B0100000, B0011100, // v
5, 8, B0111100, B1000000, B0111100, B1000000, B0111100, // w
5, 8, B1000100, B0101000, B0010000, B0101000, B1000100, // x
4, 8, B10011100, B10100000, B10100000, B1111100, B0000000, // y
3, 8, B1100100, B1010100, B1001100, B0000000, B0000000, // z
3, 8, B0001000, B0110110, B1000001, B0000000, B0000000, // {
1, 8, B1111111, B0000000, B0000000, B0000000, B0000000, // |
3, 8, B1000001, B0110110, B0001000, B0000000, B0000000, // }
4, 8, B0001000, B0000100, B0001000, B0000100, B0000000, // ~
};
 

// Configuración:
 
void setup(){
  
  m.init();           // Inicializamos a matriz
  m.setIntensity(4);  // Definimos a intensidade dos LEDs (0-15)
    
}

void loop(){

}

1.Scroll

As seguintes instrucións mostrarán un texto desprazándose a unha velocidade determinada polo conxunto de matrices

// Bucle
 
void loop() {
  
  byte c;
  delay(100);                 // Pausa entre movementos
  m.shiftLeft(false, true);
  printStringWithShift(texto1, 150);  // Envíase o texto ao módulo con desprazamento a unha velocidade
  
}


// Funcións utilizadas para mostrar o texto

void printCharWithShift(char c, int shift_speed){
  
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CAD + 7*c, 7);
  m.writeSprite(maxuse*8, 0, buffer);
  m.setColumn(maxuse*8 + buffer[0], 0);
  
  for (int i=0; i<buffer[0]+1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
  
}
 
void printStringWithShift(char* s, int shift_speed){
  
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
  
}

2.Consola

Utilizando as mesmas funcións printCharWithShift e printStringWithShift para amosar o texto que no exemplo anterior, podemos facer que se mostre o texto introducido a través da consola.

void setup(){
  
  m.init();           // Inicializamos a matriz
  m.setIntensity(4);  // Definimos a intensidade dos LEDs (0-15)
  Serial.begin(9600);  
}

// Bucle
 
void loop(){

  m.shiftLeft(false, true);
  
  while (Serial.available() > 0){
    byte c = Serial.read();
    Serial.println(c, DEC);
    printCharWithShift(c, 100);
  }

  delay(100);
  
}

// Funcións

void printCharWithShift(char c, int shift_speed){
  
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CAD + 7*c, 7);
  m.writeSprite(maxuse*8, 0, buffer);
  m.setColumn(maxuse*8 + buffer[0], 0);
  
  for (int i=0; i<buffer[0]+1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
  
}

void printStringWithShift(char* s, int shift_speed){
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

Propostas:

mfrey_led-matrix_hangman
[MichaelFrey CC-By]
Estas son algunhas ideas para traballar:

  1. Xogo de luces: Xoga coa matriz conseguindo efectos de luces chulos. A ver o que che sae!
  2. Xogo do aforcado. Crea o xogo do aforcado para xogar na consola serie. Nunha matriz de LEDs irá aparecendo a imaxe do aforcado a medida que avance o xogo e aumenten os fallos.
  3. Semáforo de peóns: Nun proxecto de cruce de semáforos, o semáforo de peóns disporá dunha pantalla de LEDs para simular o movemento do boneco verde.
  4. Farmacia: Simula nunha pantalla de LEDs o letreiro luminoso dunha farmacia, con xogos de luces. Inclúe un scroll co dato de temperatura ambiental recollido a través dun sensor de temperatura.
  5. Termómetro sentimental: Utiliza un sensor de temperatura ou de luz e establece tres rangos de niveis. Nunha matriz de LEDs no rango máis baixo mostrarase unha cara triste, no do medio unha cara normal e no superior unha cara contenta.

Mostra:

Matriz de LEDs felicitando o ano 2017

 


Deixa un comentario