Zobrazenie zdroja stránky LED Matica

Záverečný projekt predmetu DTV / LS2023 - '''Peter Bogár'''


== Úvod ==

Cieľom mojej práce je oboznámiť sa s programovaním LED matrixu pomocou Arduina. Ukážeme si funkcie a kreatívne nápady využitia 8x8 LED matice.

[[Obrázok:ard.jpg|400px|thumb|center|Vývojová doska ACROB.]]

'''Literatúra:''' 
* [https://wayoda.github.io/LedControl/pages/software Dokumentácia ku ledControl.h knižnici]


__TOC__

== Analýza  a opis riešenia ==

Budeme potrebovať 

* [https://techfun.sk/produkt/arduino-nano-every-s-nenaspajkovanymi-pinmi-original/ Arduino Nano]

* [https://techfun.sk/produkt/led-display-matrix-max7219/ Led Matrix s controllerom MAX7219]

Kontroler čip MAX7219 deserializuje dáta na dvojicu x,y signálov, ktoré rozosvietia danú led na x stĺpci a y riadku. Nám stačí poslať signál tomuto čipu jedným data pinom, namiesto 16 - jeden pre každý riadok a stĺpec.

Ak máte Arduino s nenaspájkovanými pinmi, je ich potrebné naspájkovať. Ak sú už naspájkované, preskakujte tento krok.

Začnime spojením kontroleru s Arduinom. Kontroler potrebuje 5 pinov: 
VCC = Napájanie
GND = Uzemnenie
Din = Data in
CS = Chip Select
CLK = Clock signal

Kontrolerov VCC zapojíme na Arduinov 5V pin, a GND na jeden z dvoch GND pinov Arduina. Ostatné piny sa zapájajú na ľubovoľný digitálny výstupný pin Arduina. V tomto návode budú 
Din na Arduino D8, CS na D9 a CLK na D10.

Ďalej potrebujeme nainštalovať vývojové prostredie [https://support.arduino.cc/hc/en-us/articles/360019833020-Download-and-install-Arduino-IDE Arduino IDE].
Po nainštalovaní si prostredia si importujeme knižnicu ledControl. Kliknutím na Tools v hornej lište a vybraním Manage Libraries sa dostaneme na obrazovku s prehliadačom knižníc. 
Vyhľadajme dopyt "LedControl", a stiahnime knižnicu od autora Eberhard. V tomto návode sme použili verziu 1.0.6.

<source lang="c" style="background: LightYellow;">
#include "LedControl.h"

/*
 pin 8 is connected to the DataIn 
 pin 9 is connected to CS
 pin 10 is connected to the CLK 
 
 We have only a single MAX72XX.
 */
LedControl lc=LedControl(8,10,9,1);
</source>

Zadefinujme si objekt kontrolera v kóde. Objekt lc obsahuje niekoľko vstavaných funkcií, ktorými môžeme LED maticou manipulovať. 
Tie hlavné funkcie sú:

<source lang="c" style="background: LightYellow;">
  lc.shutdown(0,false); //vypne úsporný režim (true=zapne)
  lc.setIntensity(0,0); //nastavi jasitosť displeju (druhe cislo)
  lc.clearDisplay(0); //vynuluje displej
  lc.setLed(0,7,7,true); //nastavi jednu ledku na vyp/zap
  lc.setRow(0,7,B11111111); //nastavi cely riadok naraz
  lc.setColumn(0,col,B11111111); //nastavi cely stlpec naraz
</source>

Nižsie uvedený zdrojový kód obsahuje viacero funkcií zostavených pomocou vyššie uvedených jednoduchých metód. Veľa šťastia k experimentovaniu a bavte sa!

=== Program ===


<tabs>
<tab name="Zdrojový kód"><source lang="c" style="background: LightYellow;">
//We always have to include the library
#include "LedControl.h"
#include "math.h"

/*
 pin 8 is connected to the DataIn 
 pin 9 is connected to CS
 pin 10 is connected to the CLK 
 
 We have only a single MAX72XX.
 */
LedControl lc=LedControl(8,10,9,1);



void printletter(byte letter[]){
  lc.setRow(0,0,letter[0]);
  lc.setRow(0,1,letter[1]);
  lc.setRow(0,2,letter[2]);
  lc.setRow(0,3,letter[3]);
  lc.setRow(0,4,letter[4]);

}

void writeText(char text[], long wait) {
  /* here is the data for the characters */
  byte a[5]={B01111110,B10001000,B10001000,B10001000,B01111110};
  byte b[5]={B01101100,B10010010,B10010010,B10010010,B11111110};
  byte c[5]={B01000100,B10000010,B10000010,B10000010,B01111100};
  byte d[5]={
    B01111100,
    B10000010,
    B10000010,
    B10000010,
    B11111110};
  byte e[5]={
    B00000000,
    B10010010,
    B10010010,
    B10010010,
    B11111110};
  byte f[5]={
    B00000000,
    B10010000,
    B10010000,
    B10010000,
    B11111110};
  
  byte g[5]={
    B00000000,
    B10011100,
    B10010010,
    B10000010,
    B01111100};

  byte h[5]={
    B00000000,
    B11111110,
    B00010000,
    B00010000,
    B11111110};

  byte i[5]={
    B00000000,
    B00000010,
    B10111110,
    B00100010,
    B00000000
    };

  byte j[5]={
    B00000000,
    B00000000,
    B10111110,
    B00000010,
    B00000100
    };

  byte k[5]={
    B00000000,
    B11000110,
    B00101000,
    B00010000,
    B11111110};

  byte l[5]={
    B00000000,
    B00000000,
    B00000010,
    B00000010,
    B11111110};

  byte m[5]={
    B11111110,
    B01000000,
    B00100000,
    B01000000,
    B11111110};

  byte n[5]={
    B11111110,
    B00000110,
    B00011000,
    B01100000,
    B11111110};

  byte o[5]={
      B0011100,
      B0100010,
      B0100010,
      B0100010,
      B0011100};

  byte p[5]={
    B00000000,
    B01100000,
    B10010000,
    B10010000,
    B11111110};

  byte q[5]={
    B00011010,
    B00100100,
    B00101010,
    B00100010,
    B00011100};

  byte r[5]={
    B00000000,
    B01101110,
    B10010000,
    B10010000,
    B11111110};


  byte s[5]={
    B00000000,
    B01001100,
    B10010010,
    B10010010,
    B01100100};

  byte t[5]={
    B11000000,
    B10000000,
    B11111110,
    B10000000,
    B11000000};

  byte u[5]={
    B11111110,
    B00000010,
    B00000010,
    B00000010,
    B11111110};


  byte v[5]={
    B11111000,
    B00000100,
    B00000010,
    B00000100,
    B11111000};

  byte w[5]={
    B11111000,
    B00000100,
    B00011000,
    B00000100,
    B1111100};

  byte x[5]={
    B11000110,
    B00101000,
    B00010000,
    B00101000,
    B11000110};

  byte y[5]={
    B11100000,
    B00010000,
    B00011110,
    B00010000,
    B11100000};

  byte z[5]={
    B11000110,
    B10100010,
    B1001001,
    B10001010,
    B10000110};

  byte zero[5]={
    B01111100,
    B10001010,
    B10010010,
    B10100010,
    B01111100};

  byte one[5]={
    B00000000,
    B00000000,
    B11111110,
    B01000000,
    B00000000};

  byte two[5]={
    B01110010,
    B10010010,
    B10010010,
    B01001010,
    B01100110};

  byte three[5]={
    B01101100,
    B10010010,
    B10010010,
    B10000010,
    B01000100};

  byte four[5]={
    B00000000,
    B00001000,
    B00111110,
    B00001000,
    B11111000};

  byte five[5]={
    B00000000,
    B1000110,
    B10010010,
    B10010010,
    B11110100};

  byte six[5]={
    B00000000,
    B0100110,
    B10010010,
    B10010010,
    B01111100};

  byte seven[5]={
    B00000000,
    B11000000,
    B10110000,
    B10001110,
    B10000000};

  byte eight[5]={
    B00000000,
    B01101100,
    B10010010,
    B10010010,
    B01101100};

  byte nine[5]={
    B00000000,
    B11111110,
    B10010010,
    B10010010,
    B11110010};

  byte space[5]={
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000};

  byte heart[5]={
    B00111000,
    B01000100,
    B00100010,
    B01000100,
    B00111000
    };

    byte fei[5]={
    B00000010,
    B00000000,
    B00001010,
    B00000000,
    B00101010
    };

  byte* alphabet[] = {space,fei,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,heart};
  byte* numbers[] = {zero,one,two,three,four,five,six,seven,eight,nine};


  /*for spaces use _ char, for heart use {, for fei logo use ` char*/
  /*char word[] = "`stu_fei_{";*/
  for(int i=0;i<strlen(text);i++){
    int letter = text[i];
    char* letter2;
    if(letter > 47 && letter < 58){
      letter2 = numbers[letter-48];  
    }
    else{
      letter2 = alphabet[letter - 95];
    }
    printletter(letter2);
    delay(wait);
  }
}

void rows(int delaytime) {
  for(int row=0;row<8;row++) {
    delay(delaytime);
    lc.setRow(0,row,B11111111);
    delay(delaytime);
    lc.setRow(0,row,(byte)0);
  }
}


void columns(int delaytime) {
  for(int col=0;col<9;col++) {
    delay(delaytime);
    lc.setColumn(0,col,B11111111);
    lc.setColumn(0,col-1,(byte)0);
    delay(delaytime);
  }
}

void single(int delaytime) {
  for(int i = 1; i>=0;i--){
    for(int row=0;row<8;row++) {
      for(int col=0;col<8;col++) {
        delay(delaytime);
        lc.setLed(0,row,col,i);
        delay(delaytime);
        for(int j=0;j<1;j++) {
          lc.setLed(0,row,col,!i);
          delay(delaytime);
          lc.setLed(0,row,col,i);
          delay(delaytime);
          }
      }
    }
  }
}

void settemp(){
  lc.setRow(0,5,B01010101);
  lc.setRow(0,6,B01011100);
  lc.setRow(0,7,B01000100);
}

void snowy(){
  byte snow[5]={
    B01010100,
    B00111000,
    B01111100,
    B00111000,
    B01010100};
  printletter(snow);

}


void sunny(){
  byte sun[5]={
    B00111000,
    B01111100,
    B01111100,
    B01111100,
    B00111000};
  printletter(sun);

}

void cloudy(){
  byte cloud[5]={
    B01010100,
    B10101010,
    B10000001,
    B01100101,
    B00011010};
  printletter(cloud);

}

void lightning(){
  byte flash[5]={
    B00011100,
    B00111000,
    B01111111,
    B00000110,
    B00001100};
  printletter(flash);
  delay(500);
  lc.setIntensity(0,15);
  delay(10);
  lc.setIntensity(0,0);
  delay(100);
  lc.setIntensity(0,15);
  delay(20);
  lc.setIntensity(0,0);


}

void rainy(){
  byte rain1[5]={
    B01010100,
    B10101010,
    B10000001,
    B01111111,
    B00100100};

  byte rain2[5]={
    B01010100,
    B10101010,
    B10000001,
    B01111111,
    B10010010};


  for(int i=0;i<3;i++){
    printletter(rain1);
    delay(200);
    printletter(rain2);
    delay(200);
  }

}


void brightnessSwipe(int delaytime){
  int i=8;
  for(;i>=0;i--){
    lc.setColumn(0,i,B11111111);
  }

  for(;i<=16;i++){
    lc.setIntensity(0,i);
    delay(delaytime);
  }
  for(;i>=0;i--){
    delay(delaytime);
    lc.setIntensity(0,i);
  }

  lc.clearDisplay(0);
}


//18,446,744,073,709,551,616
//18 kvintillion (18 trilion v sk num sys)

//1 125 899 906 842 624 seconds //1 biliarda
//18 764 998 447 377 minutes //18 bilion
//31 274 997 412 hours // 31 miliarda
//1 303 124 892 days
//3 567 761 years

void counter(){
  for(unsigned long i=0;i<pow(2,64);i+=1){
    for(int row=0;row<7;row++){
      lc.setRow(0,row,(byte)(i>>(row*8)));
      //delay(5);
    }
  }
}



void setup() {
  /*
   The MAX72XX is in power-saving mode on startup,
   we have to do a wakeup call
   */
  lc.shutdown(0,false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0,0);
  /* and clear the display */
  lc.clearDisplay(0);
}

void loop() {
  /*for spaces use _ char, for heart use {, for fei logo use ` char*/


  char word1[] = "stu_fei_`{";
  //char word[] = "9876543210";
  char word2[] = "peter_bogar_";

  int delaytime=350;
  //counter();
  writeText(word1, delaytime);
  delay(1000);
  writeText(word2, delaytime);
  delay(1000);

  rows(150);
  columns(150);
  
  //delay(2000);
  single(25);
  delay(1000);
  settemp();
  delay(1000);
  snowy();
  delay(2500);
  sunny();
  delay(2500);
  cloudy();
  delay(2500);
  rainy();
  delay(2500);
  lightning();
  delay(2500);
  brightnessSwipe(100);
  counter();
}

</source>
</tab>
</tabs>

Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'': 

Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]


=== Overenie ===

Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia. 
Na konci uvádzame fotku záverečnej obrazovky pred resetom. Vypísaný je tu priemerný čas a najlepší čas. 

[[Súbor:fotka.jpg|400px|thumb|center|Aplikácia.]]

'''Video:'''
<center><youtube>_l02MBu41n0</youtube></center>


[[Category:DTV]][[Category:DTV2023]]