V článku si povieme niečo o LED maticových displejoch a ich ovládanie pomocou arduina. Využijeme pritom zaujímavý hardvér ako IO MAX 7219 a tiež aj softvér knižnicu MaxMatrix pre arduino.

LED Matrix displej – vnútorné zapojenie

Na obrázku je vidieť ako sú zapojené LEDky vo vnútri displeja s veľkosťou 8x8 LED. Podľa schémy zapojenia LED vidíme že môžeme jednoducho spínať ktorúkoľvek LEDku.

Vnútorné zapojenie LED displeja 8x8

Vnútorné zapojenie LED displeja 8x8

LED driver MAX7219

Aby sa nám takýto displej ovládal jednoducho firma Maxim Integrated vyvinula integrovaný obvod MAX 7219. Samozrejme je možné displej ovládať aj bez neho ale je to komplikovanejšie a tiež nám to zaberie pomerne dosť pinov na arduine.

Integrovaný obvod MAX 7219 je sériovo ovládaný driver(ovládač), ktorý sa používa na riadenie 7-segmentových LED displejov, LED matíc a pod. Tento obvod dokáže ovládať až 8 číslic v 7-segmentovom displeji alebo 64 LED individuálne.

Viac informácii nájdete v datasheete: MAX7219-MAX7221.pdf

Základne zapojenie LED Matrix displeja a drivera MAX7219

Aby sme si ukázali ako pracovať s obvodom ukážeme si ako ho správne zapojiť k arduinu. Na zobrazenie použijeme maticu LED diód tzv. LED matrix 8x8.

Zapojenie LED displeja 8x8 s IO MAX7219 a Arduina na kontaktnom poli.

Zapojenie LED displeja 8x8 s IO MAX7219 a Arduina na kontaktnom poli.

Schéma zapojenie LED displeja 8x8 s IO MAX7219 a Arduina.

Schéma zapojenie LED displeja 8x8 s IO MAX7219 a Arduina.

Na jednoduché ovládanie integrovaného obvodu MAX7219 existuje pre Arduino knižnica s názvom MaxMatrix. Knižnicu si môžete stiahnuť a nainštalovať.

Zdrojový kód

Podrobnejší popis jednotlivých častí nájdete nižšie v zdrojom kóde. Celý projekt si môžete stiahnuť z githubu LEDMatrix_v1.

Obsah súboru LEDMatrix_v1.ino.

                
#include <MaxMatrix.h>

// nastavenie pinov, ku ktorym je pripojeny integrovany obvod MAX7219
#define PIN_DIN 8
#define PIN_CS	9
#define PIN_CLK	10
// pocet displejov pripojenych k IO MAX7219
#define LED_MATRIX_COUNT 1
// hodnota jasu/svietivosti
#define LED_MATRIX_INTENSITY 1

// vytvorenie instancie MaxMatrix
MaxMatrix maxMatrix(PIN_DIN, PIN_CS, PIN_CLK, /* Pocet zapojenych displejov */LED_MATRIX_COUNT);

void setup()
{
	// inicializacia kniznice MaxMatrix
	maxMatrix.init();
	maxMatrix.setIntensity(LED_MATRIX_INTENSITY);	//nastavenie intenzity
}

void loop()
{
	for (int j = 0; j < 8; j++)
	{
		for (int i = 0; i < 8; i++)
		{
			maxMatrix.setDot(/* stlpec => */i, /* riadok => */j, /* hodnota => */HIGH); /* rozsvietenie konkretnej LEDky */
			delay(200);
		}
		delay(200);
	}
	maxMatrix.clear(); 	// vypnutie svetkych LED
}

                
              

LED Matrix modul

Ak sa vám nechce zapájať IO s LED maticou ručne alebo si netrúfate vyrábať plošný spoj. Existuje už hotové riešenie v podobe modulu. Tento modul len jednoducho pripojíme k arduinu pomocou piatich vývodov (VCC, GND, DIN, CS, CLK). Ďalšia výhoda je v tom, že je možné pospájať viaceré takéto moduly kaskadne za sebou. A potom už je hračka vytvoriť napríklad informačný panel na ktorom bude či už aktuálny čas s teplotou alebo počet neprečítaných emailov :).

V tomto článku som použil tento modul.

LED Matrix displej modul

LED Matrix displej modul

Pokročilé funkcie

Druhý príklad ukazuje viac možností ako jednoducho je možné ovládať maticový LED displej spolu s integrovaným obvodom MAX7219 (za pomoci knižnice pre arduino).

Ukážka sa skladá z niekoľkých samostatných funkcii, v ktorých sú použité funkcie z knižnice shiftRight - posun vpravo, shiftLeft - posun vľavo, shiftDown - posun nadol a shiftUp - posun nahor.

Krátky popis jednotlivých funkcii nájdete v ukážke.

Zdrojový kód

Podrobnejší popis jednotlivých častí nájdete nižšie v zdrojom kóde. Celý projekt si môžete stiahnuť z githubu LEDMatrix_v2.

Obsah súboru LEDMatrix_v2.ino.

                
void loop()
{		
	run_right_down(50);
	delay(500);
	
	run_left_up(50);
	delay(500);
	
	run_random(10);
	delay(500);
	
	run_matrix(25, 100);
	delay(500);	
}

/*
 * Rozsvecovanie LED diod z prava dolu (po riadkoch)
 */
void run_right_down(int delayVal)
{	
	for (int row = 0; row < 8; row++)
	{	
		maxMatrix.setDot(0, row, HIGH);	
		delay(delayVal);
		for (int column = 0; column < 8; column++)
		{
			maxMatrix.shiftRight(); //posun pozicie doprava
			delay(delayVal);
		}		
		maxMatrix.shiftDown(); //posun pozicie dolu
		delay(delayVal);
	}
	maxMatrix.clear();
}

/*
 * Rozsvecovanie LED diod z lava hore (po riadkoch)
 */
void run_left_up(int delayVal)
{
	for (int row = 7; row >= 0; row--)
	{
		maxMatrix.setDot(7, row, HIGH);
		delay(delayVal);
		for (int column = 0; column < 8; column++)
		{
			maxMatrix.shiftLeft(); //posun pozicie dolava
			delay(delayVal);
		}
		maxMatrix.shiftUp(); //posun pozicie hore
		delay(delayVal);
	}
	maxMatrix.clear();
}

/*
 * Rozsvecovanie LED diod nahodne
 */
void run_random(int delayVal)
{
	for (int i = 0; i < 64; i++)
	{
		int row = random(0, 8);
		int column = random(0, 8);
		maxMatrix.setDot(column, row, HIGH);
		delay(delayVal);
		maxMatrix.clear();
	}	
}

void run_matrix_column(int delayVal, int colIndex)
{
	int row = random(0, 8);
	int rowIndexMax = 8 - row;
	maxMatrix.setDot(colIndex, rowIndexMax, HIGH);
	delay(delayVal);
	for (int rowIndex = rowIndexMax; rowIndex > 0; rowIndex--)
	{
		maxMatrix.shiftUp();
		delay(delayVal);
	}			
}

/*
 * Jednoduchy efekt alla Matrix
 */
void run_matrix(int delayValMin, int delayValMax)
{
	for (int columnIndex = 0; columnIndex < 8; columnIndex++)
	{
		int delayVal = random(delayValMin, delayValMax);
		run_matrix_column(delayVal, columnIndex);
	}		
}

    			
              

Zobrazovanie „spriteov“

Trieda MaxMatrix obsahuje metodu writeSprite, ktorou môžeme "zapnúť" niekoľko LED diód podľa dopredu zadefinovanej mapy - sprite. Príklad nižšie vysvetľuje ako je toho možné docieliť.

Zdrojový kód

Podrobnejší popis jednotlivých častí nájdete nižšie v zdrojom kóde. Celý projekt si môžete stiahnuť z githubu LEDMatrix_v3.

Obsah súboru LEDMatrix_v3.ino.

                
/*
See Sprite Generator on Plunker
http://embed.plnkr.co/3VUsekP3jC5xwSIQDVHx/preview
*/
#include <MaxMatrix.h>

//PINS setup
#define PIN_DIN 8
#define PIN_CS	9
#define PIN_CLK	10

#define LED_MATRIX_COUNT 1
#define LED_MATRIX_INTENSITY 1

// Definicie spriteov
byte rect[4][10] = {
	{8, 8, B11111111, B10000001, B10000001, B10000001, B10000001, B10000001, B10000001, B11111111 },
	{8, 8, B00000000, B01111110, B01000010, B01000010, B01000010, B01000010, B01111110, B00000000 },
	{8, 8, B00000000, B00000000, B00111100, B00100100, B00100100, B00111100, B00000000, B00000000 },
	{8, 8, B00000000, B00000000, B00000000, B00011000, B00011000, B00000000, B00000000, B00000000 }
};

byte spriteRectAlt1[] = {8, 8, /*Riadok c. 1*/B11110000,B11110000,B11110000,B11110000,B00001111,B00001111,B00001111,/*Riadok c. 7*/B00001111};
byte spriteRectAlt2[] = {8, 8, B00001111,B00001111,B00001111,B00001111,B11110000,B11110000,B11110000,B11110000};

byte cube[6][10] = {
	/*cislo 1 na hracej kocke*/{8, 8, B00000000,B00000000,B00000000,B00011000,B00011000,B00000000,B00000000,B00000000},
	/*cislo 2 na hracej kocke*/{8, 8, B00000000,B00000110,B00000110,B00000000,B00000000,B01100000,B01100000,B00000000},
	/*cislo 3 na hracej kocke*/{8, 8, B00000011,B00000011,B00000000,B00011000,B00011000,B00000000,B11000000,B11000000},
	/*cislo 4 na hracej kocke*/{8, 8, B11000011,B11000011,B00000000,B00000000,B00000000,B00000000,B11000011,B11000011},
	/*cislo 5 na hracej kocke*/{8, 8, B11000011,B11000011,B00000000,B00011000,B00011000,B00000000,B11000011,B11000011},
	/*cislo 6 na hracej kocke*/{8, 8, B01100110,B01100110,B00000000,B01100110,B01100110,B00000000,B01100110,B01100110}
};
	
MaxMatrix maxMatrix(PIN_DIN, PIN_CS, PIN_CLK, LED_MATRIX_COUNT);

void setup()
{
	maxMatrix.init();
	maxMatrix.setIntensity(LED_MATRIX_INTENSITY);
}

void loop()
{
	run_rect(200);
	delay(500);
	
	run_altrect(500);
	delay(500);
	
	run_cube(2000);
	delay(500);
}

void run_rect(int delayVal)
{
	for (int r=0; r < 4; r++)
	{
		byte *t = (byte *)(rect[r]);
		// funkcia writeSprite nastavenie LED diod podla definicie v poli
		maxMatrix.writeSprite(/*int x=*/0, /*int y=*/0, /*const byte* sprite=*/t); 
		delay(delayVal);
	}
	maxMatrix.clear();
}

void run_altrect(int delayVal)
{
	maxMatrix.writeSprite(0, 0, spriteRectAlt1);
	delay(delayVal);
	maxMatrix.clear();	
	delay(delayVal);
	maxMatrix.writeSprite(0, 0, spriteRectAlt2);
	delay(delayVal);
	maxMatrix.clear();
	delay(delayVal);
}

void run_cube(int delayVal)
{
	int cubeNumber = random(0, 6);
	byte *sprite = (byte *)(cube[cubeNumber]);
	maxMatrix.writeSprite(0, 0, sprite);
	delay(delayVal);
}

    			
              

Pomôcka na vytváranie spriteov „Sprite Generator“

Dobrý programátor by mal rozmýšľať tak, aby si uľahčil prácu :). Preto som vytvoril jednoduchý nástroj na generovanie kódu. Ovládanie tejto aplikácie by malo byť relatívne jednoduché. Stačí kliknúť na požadovaný štvorec, ktorý vlastne predstavuje jednu LEDku v displeji. Kliknutím na štvorec nastavíme rozsvietenie požadovanej LEDky. Počas klikania sa automaticky generuje kód nižšie. Tiež môžete zvoliť aj názov premennej pre vygenerovaný sprite. A to tak, že zadáte alebo upravíte text v políčku "Sprite name". Vygenerovaný kód potom kopipejstom vložíte do svojej aplikácie pre arduino.

LED Matrix Sprite Generator

Sprite Generator pre 8x8 LED matrix

Sprite Generator pre 8x8 LED matrix

Záver

Ak budete mať nejaké otázky k článku, kľudne ich napíšte do komentárov nižšie.