Operácie

LED Matica: Rozdiel medzi revíziami

Zo stránky SensorWiki

← Predchádzajúca úpravaĎalšia úprava →
StudentDTV (diskusia | príspevky)
1 300 editací
StudentDTV (diskusia | príspevky)
1 300 editací
Riadok 6: Riadok 6:
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.
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.]]
[[Súbor:Full_bogar.jpg|400px|center|Arduino s LED Matrixom.]]


'''Literatúra:'''  
'''Literatúra:'''  

Verzia z 20:47, 18. jún 2023

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.

Chyba pri vytváraní náhľadu: Súbor s rozmermi väčšími než 12,5 MP
Arduino s LED Matrixom.

Literatúra:


Analýza a opis riešenia

Budeme potrebovať

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 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. 

#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);

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ú: 

  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

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

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

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: 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.

Aplikácia.

Video:

Zdroj: „https://senzor.robotika.sk/sensorwiki/index.php?title=LED_Matica&oldid=14597“