아두이노로 LED matrix 제어하기 #12 : 화면 전환 효과 만들기

2018. 3. 9. 13:39

Arduino/Display

Arduino LedControl Library : 화면 전환 효과 내기

별건 아니고, 정리하는 의미에서 몇 가지 다른 효과를 만들어 보겠습니다.

기본 적인 코드 구성과 필요한 설명은 이전 글들에서 다루었기 때문에 이번 글에선 소개 정도로만 설명하겠습니다.

나만의 헤더 파일 만들기

우선, 이전 글에서 다루었던 예제를 손을 좀 보겠습니다. LED 매트릭스에 출력하기 위해선 패턴 데이터가 미리 저장되어 있어야 합니다. 그래서, 어떤 LED를 켜서 그림을 만들지 일일이 배열로 저장해서 다루었는데, 이 때문에 프로그램 소스가 너무 길어지는  단점이 있습니다.

패턴 데이터는 변하지 않기 때문에 헤더 파일로 만들어서 접근하는 편이 프로그램도 간단해져서 훨씬 좋고, 또 단순히 데이터만 담는 헤더 파일은 만들기도 쉽습니다. 적당한 파일명으로 텍스트 파일을 만든 후, 프로그램 소스와 동일한 폴더에 넣어 주면 아두이노 개발 환경이 자동으로 불러와 줍니다! 

 #include "LedControl.h"
//
LedControl lc = LedControl(12,11,10,4);
byte data[26][8] = {
{
B00000000,
B00111100,
B01100110,
B01100110,
B01111110,
B01100110,
B01100110,
B01100110
},{
B00000000,
B01111100,
B01100110,
B01100110,
B01111100,
B01100110,
B01100110,
B01111100
},{
B00000000,
B00111100,
B01100110,
B01100000,
B01100000,
B01100000,
B01100110,
B00111100
},{
B00000000,
B01111100,
B01100110,
B01100110,
B01100110,
B01100110,
B01100110,
B01111100
},{
B00000000,
B01111110,
B01100000,
B01100000,
B01111100,
B01100000,
B01100000,
B01111110
},{
B00000000,
B01111110,
B01100000,
B01100000,
B01111100,
B01100000,
B01100000,
B01100000
},{
B00000000,
B00111100,
B01100110,
B01100000,
B01100000,
B01101110,
B01100110,
B00111100
},{
B00000000,
B01100110,
B01100110,
B01100110,
B01111110,
B01100110,
B01100110,
B01100110
},{
B00000000,
B00111100,
B00011000,
B00011000,
B00011000,
B00011000,
B00011000,
B00111100
},{
B00000000,
B00011110,
B00001100,
B00001100,
B00001100,
B01101100,
B01101100,
B00111000
},{
B00000000,
B01100110,
B01101100,
B01111000,
B01110000,
B01111000,
B01101100,
B01100110
},{
B00000000,
B01100000,
B01100000,
B01100000,
B01100000,
B01100000,
B01100000,
B01111110
},{
B00000000,
B01100011,
B01110111,
B01111111,
B01101011,
B01100011,
B01100011,
B01100011
},{
B00000000,
B01100011,
B01110011,
B01111011,
B01101111,
B01100111,
B01100011,
B01100011
},{
B00000000,
B00111100,
B01100110,
B01100110,
B01100110,
B01100110,
B01100110,
B00111100
},{
B00000000,
B01111100,
B01100110,
B01100110,
B01100110,
B01111100,
B01100000,
B01100000
},{
B00000000,
B00111100,
B01100110,
B01100110,
B01100110,
B01101110,
B00111100,
B00000110
},{
B00000000,
B01111100,
B01100110,
B01100110,
B01111100,
B01111000,
B01101100,
B01100110
},{
B00000000,
B00111100,
B01100110,
B01100000,
B00111100,
B00000110,
B01100110,
B00111100
},{
B00000000,
B01111110,
B01011010,
B00011000,
B00011000,
B00011000,
B00011000,
B00011000
},{
B00000000,
B01100110,
B01100110,
B01100110,
B01100110,
B01100110,
B01100110,
B00111110
},{
B00000000,
B01100110,
B01100110,
B01100110,
B01100110,
B01100110,
B00111100,
B00011000
},{
B00000000,
B01100011,
B01100011,
B01100011,
B01101011,
B01111111,
B01110111,
B01100011
},{
B00000000,
B01100011,
B01100011,
B00110110,
B00011100,
B00110110,
B01100011,
B01100011
},{
B00000000,
B01100110,
B01100110,
B01100110,
B00111100,
B00011000,
B00011000,
B00011000
},{
B00000000,
B01111110,
B00000110,
B00001100,
B00011000,
B00110000,
B01100000,
B01111110
}};
//
void setup() {
lc.shutdown(0, false);
lc.shutdown(1, false);
lc.shutdown(2, false);
lc.shutdown(3, false);
//
lc.setIntensity(0,8);
lc.setIntensity(1,8);
lc.setIntensity(2,8);
lc.setIntensity(3,8);
//
lc.clearDisplay(0);
lc.clearDisplay(1);
lc.clearDisplay(2);
lc.clearDisplay(3);
}
//
void loop() {
//
int i, j, k;
byte buffers[4+1][8];
//
for (i = 0; i < 4; i++) {
for (j = 0; j < 8; j++) {
buffers[i][j] = B00000000;
}
}
// 문자 슬라이드 처리
for (i = 0; i < 26; i++) { // 전체 글자수 만큼 반복
memcpy(&buffers[4], &data[i], sizeof(data[0]));
//
for (j = 0; j < 8; j++) { // 한 글자는 8열이므로, 글자당 8번 수행
for (k = 0; k < 8; k++) { // 한 글자는 8행
// 슬라이드 처리
buffers[0][k] = (buffers[0][k] << 1) | (buffers[1][k] >> 7);
buffers[1][k] = (buffers[1][k] << 1) | (buffers[2][k] >> 7);
buffers[2][k] = (buffers[2][k] << 1) | (buffers[3][k] >> 7);
buffers[3][k] = (buffers[3][k] << 1) | (buffers[4][k] >> 7);
buffers[4][k] = (buffers[4][k] << 1);
}
for (k = 0; k < 8; k++) { // 슬라이드 처리후 출력
// 출력 코드
lc.setRow(0, k, buffers[0][k]);
lc.setRow(1, k, buffers[1][k]);
lc.setRow(2, k, buffers[2][k]);
lc.setRow(3, k, buffers[3][k]);
}
delay(10);
}
}
delay(1000);
}

이전 글에서 만든 소스입니다. 가로 방향으로 알파벳 26글자를 슬라이드 하는 소스인데, 26글자에 대한 패턴이 상당히 긴 부분을 차지합니다. 이 부분을 헤더 파일로 따로 만들겠습니다.

우선, 프로그램 소스 파일과 동일한 폴더에 메모장 등을 이용해 적당한 이름의 텍스트 파일을 만듭니다. 확장자는 꼭 "h" 한 글자로 지정하고, 패턴 데이터를 옮겨서 저장해 줍니다.

헤더 파일을 생성한 후, 프로그램 소스를 닫았다 다시 열면 위와 같이 별도의 탭으로 알아서 열어 줍니다. 편집도 여기서 하면 되구요!

#include "LedControl.h"
#include "LedData.h"
//
LedControl lc = LedControl(12,11,10,4);
//

마지막으로, 프로그램 소스에서 #include문을 이용해 이 헤더 파일을 사용하겠다고 선언해주면 됩니다. 이렇게 하고 실행해 보면 동일한 결과를 확인할 수 있습니다.

애니메이션 효과 만들기

일정 시간안에 여러 개의 프레임을 순서대로 출력하면 애니메이션 효과를 표현할 수 있겠죠! 그럴 듯한 패턴이 없어서 그냥 화살표를 돌려 보도록 하겠습니다.

const byte arrow[][8] = {
{
  B00000000,
  B00001000,
  B00011100,
  B00111110,
  B01111111,
  B00011100,
  B00011100,
  B00011100
},{
  B00000000,
  B00011100,
  B00011100,
  B00011100,
  B01111111,
  B00111110,
  B00011100,
  B00001000
},{
  B00000000,
  B00001000,
  B00001100,
  B01111110,
  B01111111,
  B01111110,
  B00001100,
  B00001000
},{
  B00000000,
  B00001000,
  B00011000,
  B00111111,
  B01111111,
  B00111111,
  B00011000,
  B00001000
}};

우선 상, 하, 좌, 우, 4개의 화살표를 패턴으로 헤더 파일에 저장하였습니다. "const"는 데이터의 변동이 없는 상수 데이터를 의미합니다.

void bufInMotion() {
  for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 4; j++) {
      for (int k = 0; k < 8; k++) {
        lc.setRow(0, k, arrow[j][k]);
        if (i > 1) {
          lc.setRow(1, k, arrow[j][k]);
        }
        if (i > 3) {
          lc.setRow(2, k, arrow[j][k]);
        }
        if (i > 5) {
          lc.setRow(3, k, arrow[j][k]);
        }
      }
      delay(100);
    }
  }
}

애니메이션 수행 코드입니다. 가장 바깥 쪽 for문의 "i" 값은 전체 실행 횟수입니다. 두 번째 for문은 패턴 4개를 돌아가며 출력하기 위한 것이고, 가장 안쪽 for문은 8개의 행을 출력하여 하나의 패턴을 완성하는 코드입니다. 단순한 코드인데, 중간의 if문은 각 모듈의 시작 시간을 달리 하기 위함입니다.

왼쪽에서 오른쪽으로 슬라이드 효과 내기

이제 까지의 슬라이드 효과는 항상 오른쪽에서 왼쪽으로 흘러 가는 소스만 작성했는데, 아래와 같이 반대 방향 코드도 작성해 보았습니다. for문의 인수만 잘 지정하면 쉽게 구현할 수 있습니다.

const byte shift[8] = {
  B00001111,
  B00011111,
  B00111111,
  B01111111,
  B11111110,
  B11111100,
  B11111000,
  B11110000
};

출력할 패턴을 헤더 파일에 삽입했습니다.

void bufInShift2() {
  int i, j, k;
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 8; j++) {
      if (j == 0) memcpy(&buffers[4], &shift, sizeof(buffers[0]));
      for (k = 0; k < 8; k++) {
        buffers[3][k] = (buffers[3][k] >> 1) | (buffers[2][k] << 7);
        buffers[2][k] = (buffers[2][k] >> 1) | (buffers[1][k] << 7);
        buffers[1][k] = (buffers[1][k] >> 1) | (buffers[0][k] << 7);
        buffers[0][k] = (buffers[0][k] >> 1) | (buffers[4][k] << 7);
        buffers[4][k] = (buffers[4][k] >> 1);
      }
      for (k = 0; k < 8; k++) {
        lc.setRow(0, k, buffers[0][k]);
        lc.setRow(1, k, buffers[1][k]);
        lc.setRow(2, k, buffers[2][k]);
        lc.setRow(3, k, buffers[3][k]);
      }
      delay(30);
    }
  }
}

완성된 코드입니다. 보는 바와 같이 루프가 반대쪽 부터 돌도록 for문 내의 배열 첨자만 조절하였습니다.

페이드 인(Fade In) 효과 표현하기

이번에는 페이드 인 효과를 흉내내 보겠습니다. 출력 데이터의 첫 번째 열부터 마지막 열까지 순차적으로 출력하여 마치 페이드 인 효과처럼 보이도록 하는데, 기존의 setRow() 함수로는 좀 어렵습니다. 각 모듈의 1번 열부터 8번 열(코드상 0번 ~ 7번)까지 한 번에 출력하기 때문에 구현하기가 복잡합니다. 대신, setLed() 함수는 개별 LED 단위로 on/off 할 수 있으므로 간단하게 처리할 수 있습니다.

// fade In 처음부터
void bufInFadeFirst() {
  int i, j, k;
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 8; j++) {
      for (k = 0; k < 8; k++) {
        lc.setLed(i, k, j, bitRead(fade1[i][k], 7 - j));
      }
      delay(50);
    }
  }
}

출력할 데이터는 fade1[][8] 배열에 저장되어 있습니다. 이 데이터는 byte type이기 때문에 8비트가 하나의 단위인데, setLed() 함수는 하나의 비트값만 필요합니다. bitRead() 함수는 특정 데이터에서 원하는 자리의 비트값을 읽어 반환해주는 함수이며, 이를 이용해서 byte 단위 데이터의 특정 비트값을 구할 수 있습니다.

바깥 for문은 모듈 0번부터 3번까지, 중간 for문은 0번 열부터 7번 열까지, 안쪽 for문은 0번 행부터 7번 행까지 반복해 줍니다.

// fade In 끝부터
void bufInFadeEnd() {
  int i, j, k;
  for (i = 3; i >= 0 ; i--) {
    for (j = 0; j < 8; j++) {
      for (k = 0; k < 8; k++) {
        lc.setLed(i, k, 7 - j, bitRead(fade2[i][k], j));
      }
      delay(50);
    }
  }
}

같은 동작인데, 끝부터 출력되는 코드입니다.

// fade In 중간부터
void bufInFadeMid() {
  int Cnt, i, j, k;
  int m1 = 1, m2 = 2;
  for (Cnt = 0; Cnt < 16; Cnt++) {
    if (Cnt >= 8) {
      m1 = 0;
      m2 = 3;
      i = 15 - Cnt;
      j = Cnt - 8;
    } else {
      i = 7 - Cnt;
      j = Cnt;
    }
    for (k = 0; k < 8; k++) {
      lc.setLed(m1, k, i, bitRead(fade3[m1][k], i));
      lc.setLed(m2, k, j, bitRead(fade3[m2][k], j));
    }
    delay(50);
  }
}

화면 중간부터 페이드 인하는 코드입니다. 위에서 만든 두 코드를 조합하여 반씩 완성하도록 구성하였습니다.

예제로 확인

이제 까지 만든 표현들을 적당히 섞이서 만든 소스입니다. 전체 소스 및 헤더 파일, 실행 동영상을 아래와 같이 확인할 수 있습니다.

#include "LedControl.h"
#include "LedData.h"
//
LedControl lc = LedControl(12,11,10,4);
//
byte buffers[4+1][8];
//
void setup() {
  lc.shutdown(0, false);
  lc.shutdown(1, false);
  lc.shutdown(2, false);
  lc.shutdown(3, false);
  //
  lc.setIntensity(0,8);
  lc.setIntensity(1,8);
  lc.setIntensity(2,8);
  lc.setIntensity(3,8);
  //
  lc.clearDisplay(0);
  lc.clearDisplay(1);
  lc.clearDisplay(2);
  lc.clearDisplay(3);
}
//
void loop() {
  //
  bufIn();
  delay(1000);
  bufInBlink();
  delay(1000);
  bufInMotion();
  delay(1000);
  bufInShift();
  delay(1000);
  bufInShift2();
  delay(1000);
  bufInFadeFirst();
  delay(1000);
  bufInFadeEnd();
  delay(1000);
  bufInFadeMid();
  delay(1000);
}
// 출력 데이터를 buffers에 전송
void bufIn() {
  for (int i = 0; i < 4; i++) {
    memcpy(&buffers[i], &led[i], sizeof(buffers[0]));
  }
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 8; j++) {
      lc.setRow(i, j, buffers[i][j]);
    }
  }
}
// 깜박임 효과
void bufInBlink() {
  bool flag = true;
  for (int Cnt = 0; Cnt < 6; Cnt++) {
    if (flag) {
      for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 8; j++) {
          lc.setRow(i, j, 0);
        }
      }
      flag = false;
    } else {
      for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 8; j++) {
          lc.setRow(i, j, buffers[i][j]);
        }
      }
      flag = true;
    }
    delay(100);
  }
}
// 문자 슬라이드 효과
void bufInShift() {
  int i, j, k;
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 8; j++) {
      buffers[i][j] = 0;
    }
  }
  for (i = 0; i < welcomeLen; i++) {
    for (j = 0; j < 8; j++) {
      if (j == 0) memcpy(&buffers[4], &welcome[i], sizeof(buffers[0]));
      for (k = 0; k < 8; k++) {
        buffers[0][k] = (buffers[0][k] << 1) | (buffers[1][k] >> 7);
        buffers[1][k] = (buffers[1][k] << 1) | (buffers[2][k] >> 7);
        buffers[2][k] = (buffers[2][k] << 1) | (buffers[3][k] >> 7);
        buffers[3][k] = (buffers[3][k] << 1) | (buffers[4][k] >> 7);
        buffers[4][k] = (buffers[4][k] << 1);
      }
      for (k = 0; k < 8; k++) {
        lc.setRow(0, k, buffers[0][k]);
        lc.setRow(1, k, buffers[1][k]);
        lc.setRow(2, k, buffers[2][k]);
        lc.setRow(3, k, buffers[3][k]);
      }
      delay(30);
    }
  }
}
void bufInShift2() {
  int i, j, k;
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 8; j++) {
      if (j == 0) memcpy(&buffers[4], &shift, sizeof(buffers[0]));
      for (k = 0; k < 8; k++) {
        buffers[3][k] = (buffers[3][k] >> 1) | (buffers[2][k] << 7);
        buffers[2][k] = (buffers[2][k] >> 1) | (buffers[1][k] << 7);
        buffers[1][k] = (buffers[1][k] >> 1) | (buffers[0][k] << 7);
        buffers[0][k] = (buffers[0][k] >> 1) | (buffers[4][k] << 7);
        buffers[4][k] = (buffers[4][k] >> 1);
      }
      for (k = 0; k < 8; k++) {
        lc.setRow(0, k, buffers[0][k]);
        lc.setRow(1, k, buffers[1][k]);
        lc.setRow(2, k, buffers[2][k]);
        lc.setRow(3, k, buffers[3][k]);
      }
      delay(30);
    }
  }
}
void bufInMotion() {
  for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 4; j++) {
      for (int k = 0; k < 8; k++) {
        lc.setRow(0, k, arrow[j][k]);
        if (i > 1) {
          lc.setRow(1, k, arrow[j][k]);
        }
        if (i > 3) {
          lc.setRow(2, k, arrow[j][k]);
        }
        if (i > 5) {
          lc.setRow(3, k, arrow[j][k]);
        }
      }
      delay(100);
    }
  }
}
// fade In 처음부터
void bufInFadeFirst() {
  int i, j, k;
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 8; j++) {
      for (k = 0; k < 8; k++) {
        lc.setLed(i, k, j, bitRead(fade1[i][k], 7 - j));
      }
      delay(50);
    }
  }
}
// fade In 끝부터
void bufInFadeEnd() {
  int i, j, k;
  for (i = 3; i >= 0 ; i--) {
    for (j = 0; j < 8; j++) {
      for (k = 0; k < 8; k++) {
        lc.setLed(i, k, 7 - j, bitRead(fade2[i][k], j));
      }
      delay(50);
    }
  }
}
// fade In 중간부터
void bufInFadeMid() {
  int Cnt, i, j, k;
  int m1 = 1, m2 = 2;
  for (Cnt = 0; Cnt < 16; Cnt++) {
    if (Cnt >= 8) {
      m1 = 0;
      m2 = 3;
      i = 15 - Cnt;
      j = Cnt - 8;
    } else {
      i = 7 - Cnt;
      j = Cnt;
    }
    for (k = 0; k < 8; k++) {
      lc.setLed(m1, k, i, bitRead(fade3[m1][k], i));
      lc.setLed(m2, k, j, bitRead(fade3[m2][k], j));
    }
    delay(50);
  }
}
byte data[26][8] = {
{
  B00000000,
  B00111100,
  B01100110,
  B01100110,
  B01111110,
  B01100110,
  B01100110,
  B01100110
},{
  B00000000,
  B01111100,
  B01100110,
  B01100110,
  B01111100,
  B01100110,
  B01100110,
  B01111100
},{
  B00000000,
  B00111100,
  B01100110,
  B01100000,
  B01100000,
  B01100000,
  B01100110,
  B00111100
},{
  B00000000,
  B01111100,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01111100
},{
  B00000000,
  B01111110,
  B01100000,
  B01100000,
  B01111100,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B01111110,
  B01100000,
  B01100000,
  B01111100,
  B01100000,
  B01100000,
  B01100000
},{
  B00000000,
  B00111100,
  B01100110,
  B01100000,
  B01100000,
  B01101110,
  B01100110,
  B00111100
},{
  B00000000,
  B01100110,
  B01100110,
  B01100110,
  B01111110,
  B01100110,
  B01100110,
  B01100110
},{
  B00000000,
  B00111100,
  B00011000,
  B00011000,
  B00011000,
  B00011000,
  B00011000,
  B00111100
},{
  B00000000,
  B00011110,
  B00001100,
  B00001100,
  B00001100,
  B01101100,
  B01101100,
  B00111000
},{
  B00000000,
  B01100110,
  B01101100,
  B01111000,
  B01110000,
  B01111000,
  B01101100,
  B01100110
},{
  B00000000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B01100011,
  B01110111,
  B01111111,
  B01101011,
  B01100011,
  B01100011,
  B01100011
},{
  B00000000,
  B01100011,
  B01110011,
  B01111011,
  B01101111,
  B01100111,
  B01100011,
  B01100011
},{
  B00000000,
  B00111100,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B00111100
},{
  B00000000,
  B01111100,
  B01100110,
  B01100110,
  B01100110,
  B01111100,
  B01100000,
  B01100000
},{
  B00000000,
  B00111100,
  B01100110,
  B01100110,
  B01100110,
  B01101110,
  B00111100,
  B00000110
},{
  B00000000,
  B01111100,
  B01100110,
  B01100110,
  B01111100,
  B01111000,
  B01101100,
  B01100110
},{
  B00000000,
  B00111100,
  B01100110,
  B01100000,
  B00111100,
  B00000110,
  B01100110,
  B00111100
},{
  B00000000,
  B01111110,
  B01011010,
  B00011000,
  B00011000,
  B00011000,
  B00011000,
  B00011000
},{
  B00000000,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B00111110
},{
  B00000000,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B00111100,
  B00011000
},{
  B00000000,
  B01100011,
  B01100011,
  B01100011,
  B01101011,
  B01111111,
  B01110111,
  B01100011
},{
  B00000000,
  B01100011,
  B01100011,
  B00110110,
  B00011100,
  B00110110,
  B01100011,
  B01100011
},{
  B00000000,
  B01100110,
  B01100110,
  B01100110,
  B00111100,
  B00011000,
  B00011000,
  B00011000
},{
  B00000000,
  B01111110,
  B00000110,
  B00001100,
  B00011000,
  B00110000,
  B01100000,
  B01111110
}};
const byte led[][8] = {
{
  B00000000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B01111110,
  B01100000,
  B01100000,
  B01111100,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B01111100,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01111100
},
{
  B00000000,
  B00100010,
  B01110111,
  B01111111,
  B01111111,
  B00111110,
  B00011100,
  B00001000
}};
const byte arrow[][8] = {
{
  B00000000,
  B00001000,
  B00011100,
  B00111110,
  B01111111,
  B00011100,
  B00011100,
  B00011100
},{
  B00000000,
  B00011100,
  B00011100,
  B00011100,
  B01111111,
  B00111110,
  B00011100,
  B00001000
},{
  B00000000,
  B00001000,
  B00001100,
  B01111110,
  B01111111,
  B01111110,
  B00001100,
  B00001000
},{
  B00000000,
  B00001000,
  B00011000,
  B00111111,
  B01111111,
  B00111111,
  B00011000,
  B00001000
}};
const byte welcome[][8] = {
{
  B00000000,
  B01111110,
  B01011010,
  B00011000,
  B00011000,
  B00011000,
  B00011000,
  B00011000
},{
  B00000000,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B00111110
},{
  B00000000,
  B01111100,
  B01100110,
  B01100110,
  B01111100,
  B01111000,
  B01101100,
  B01100110
},{
  B00000000,
  B01111110,
  B01011010,
  B00011000,
  B00011000,
  B00011000,
  B00011000,
  B00011000
},{
  B00000000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B01111110,
  B01100000,
  B01100000,
  B01111100,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B00111100,
  B01100110,
  B01100000,
  B00111100,
  B00000110,
  B01100110,
  B00111100
},{
  B00000000,
  B01100110,
  B01100110,
  B01100110,
  B01111110,
  B01100110,
  B01100110,
  B01100110
},{
  B00000000,
  B01111110,
  B01100000,
  B01100000,
  B01111100,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01100000,
  B01111110
},{
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B01100000,
  B01100000
},{
  B00000000,
  B01100110,
  B01101100,
  B01111000,
  B01110000,
  B01111000,
  B01101100,
  B01100110
},{
  B00000000,
  B01111100,
  B01100110,
  B01100110,
  B01111100,
  B01111000,
  B01101100,
  B01100110
}};
const int welcomeLen = sizeof(welcome)/8;
const byte fade1[][8] = {
{
  B11111111,
  B10000000,
  B10011100,
  B10111110,
  B10111110,
  B10111110,
  B10011100,
  B11111111
},{
  B11111111,
  B00000000,
  B00011100,
  B00111110,
  B00111110,
  B00111110,
  B00011100,
  B11111111
},{
  B11111111,
  B00000000,
  B00011100,
  B00111110,
  B00111110,
  B00111110,
  B00011100,
  B11111111
},{
  B11111111,
  B00000001,
  B00011101,
  B00111111,
  B00111111,
  B00111111,
  B00011101,
  B11111111
}};
const byte fade2[][8] = {
{
  B00000000,
  B00001000,
  B00011100,
  B00011100,
  B00111110,
  B00111110,
  B01111111,
  B01111111
},{
  B00000000,
  B01111111,
  B01111111,
  B00111110,
  B00111110,
  B00011100,
  B00011100,
  B00001000
},{
  B00000000,
  B01100000,
  B01111000,
  B01111110,
  B01111111,
  B01111110,
  B01111000,
  B01100000
},{
  B00000000,
  B00000011,
  B00001111,
  B00111111,
  B01111111,
  B00111111,
  B00001111,
  B00000011
}};
const byte fade3[][8] = {
{
  B11111111,
  B11111111,
  B11100011,
  B11011101,
  B11011101,
  B11011101,
  B11100011,
  B11111111
},{
  B11111111,
  B11111111,
  B11100011,
  B11011101,
  B11011101,
  B11011101,
  B11100011,
  B11111111
},{
  B11111111,
  B11111111,
  B11100011,
  B11011101,
  B11011101,
  B11011101,
  B11100011,
  B11111111
},{
  B11111111,
  B11111111,
  B11100011,
  B11011101,
  B11011101,
  B11011101,
  B11100011,
  B11111111
}};
const byte shift[8] = {
  B00001111,
  B00011111,
  B00111111,
  B01111111,
  B11111110,
  B11111100,
  B11111000,
  B11110000
};

이상으로 LED matrix에 대한 연재를 마치겠습니다.

0 Comments