Texto, figuras e debuxos

Imos ver o que somos capaces de facer cunha matriz de LEDs no mClon. Nesta páxina tes as instrucións de montaxe e conexión.

Librería

Para facer os nosos programas debemos utilizar unha librería que nos facilite a tarefa. A que propoñemos aquí é a librería 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=13, 1 matriz

LedControl lc=LedControl(12,11,13,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);      // Apagamos todo 
}

Prácticas:

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

Selecciona a pestana coa práctica que che interese:

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,"mClon");
  delay(1000);
  lc.writeString(0,"1234567890");
  delay(1000);
  
}

 

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);
// Funcións:

// 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="mclon";
  for (int n=0; n<palabra.length();n++){
    char c = palabra.charAt(n) ;
    scrollLeft(c, 150);
  }

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[] = {   
  B00011110,
  B00111111,
  B01111111,
  B11111110,
  B11111110,
  B01111111,
  B00111111,
  B00011110};
 
byte corazon2[] = {
  B00011110,
  B00100001,
  B01000001,
  B10000010,
  B10000010,
  B01000001,
  B00100001,
  B00011110};

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

Retos:

  • Inicio: Imos empezar os programas con luces. Fai que ao premer no pulsador a matriz de leds amose unha mensaxe ou debuxos. Crea unha función para que poidas incorporala facilmente noutros programas.
  • Debuxo: Fai que cada vez que o sensor ultrasónico detecte un obxecto apareza un debuxo na matriz de leds (un boneco, unha cara sorrinte, …). Se non ten un obxecto diante deberá desaparecer. Proba facer que o debuxo teña movemento mentres hai un obxecto diante do sensor, como fixemos co exemplo do corazón do inicio desta páxina.
  • Conta-latas: No programa no que o mClon vai por unha liña rodeando ou apartando latas engade un contador e amosa na matriz de leds o número de latas que leva atopado.
  • Saímos da liña?: No programa de seguir unha liña, cada vez que o mClon sae da liña deberán acenderse os leds da matriz da columna do lado polo que saíu. Se está completamente fóra deberán acenderse catro columnas.
  • Detector de nivel:  Fai que as filas da matriz se vaian acendendo en función do nivel detectado por un sensor. Por exemplo, co sensor ultrasónico, a medida que un obxecto se atopa máis cerca se irán acendendo máis filas.
  • Luces ao chou: Utiliza a función random para crear un patrón de luces aleatorio coma este: