아두이노로 LED CUBE 만들기

우선 이 프로젝트를 설명드리자면 단색 LED를 사용하여 4X4X4 LED CUBE를 만드는 프로젝트입니다.

 

사용한 툴 : Visual studio code, Arduino IDE

---

재료

LED 64개

아두이노 나노 1개

저항 220옴 4개

우드락 (선택)

---

하드웨어 만들기

 

1. 우드락에 LED크기로 구멍을 뚫는다.

    구멍은 4X4 크기로 일정한 간격으로 뚫는다.

2. 구멍에 LED를 넣어서 고정한다.

3. 고정한 LED의 +극을 연결한다.

4. 3의 과정을 4번 반복한다.

5. 16가 연결된 LED 4개의 GED를 층으로 연결한다.

6. GED의 선과 층당 1개의 선을 빼서 연결한다.

    +선 연결 : 4층 A3,3층 A2,2층 A1 1층 A0

     -선 연결 : D0~D13, A4~A5 여기서 아날로그 4,5는 디지털의 선이 부족해서 사용하는 것이므로 D-2, D-1로 생각하면 된다.

---

소프트웨어 만들기

 

코드 (소프트웨어는 각자 만들고 싶은 기능이 다르기 때문에 본인이 약간씩 수정하시기 바랍니다.)

int layer[4] = {A3, A2, A1, A0};
int column[16] = {13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, A5, A4};
int time = 250;

void setup()
{

    for (int i = 0; i < 16; i++)
    {
        pinMode(column[i], OUTPUT);
    }

    for (int i = 0; i < 4; i++)
    {
        pinMode(layer[i], OUTPUT);
    }

    randomSeed(analogRead(10));
}

void loop()
{
    turnEverythingOff();
    flickerOn();
    turnEverythingOn();
    delay(time);
    turnOnAndOffAllByLayerUpAndDownNotTimed();
    layerstompUpAndDown();
    spiralInAndOut();
    turnOnAndOffAllByColumnSideways();
    delay(time);
    aroundEdgeDown();
    turnEverythingOff();
    randomflicker();
    randomRain();
    diagonalRectangle();
    goThroughAllLedsOneAtATime();
    propeller();
    spiralInAndOut();
    flickerOff();
    turnEverythingOff();
    delay(2000);
}

void turnEverythingOff()
{
    for (int i = 0; i < 16; i++)
    {
        digitalWrite(column[i], 1);
    }
    for (int i = 0; i < 4; i++)
    {
        digitalWrite(layer[i], 0);
    }
}

void turnEverythingOn()
{
    for (int i = 0; i < 16; i++)
    {
        digitalWrite(column[i], 0);
    }

    for (int i = 0; i < 4; i++)
    {
        digitalWrite(layer[i], 1);
    }
}

void turnColumnsOff()
{
    for (int i = 0; i < 16; i++)
    {
        digitalWrite(column[i], 1);
    }
}

void flickerOn()
{
    int i = 150;
    while (i != 0)
    {
        turnEverythingOn();
        delay(i);
        turnEverythingOff();
        delay(i);
        i -= 5;
    }
}

void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
    int x = 75;
    for (int i = 5; i != 0; i--)
    {
        turnEverythingOn();
        for (int i = 4; i != 0; i--)
        {
            digitalWrite(layer[i - 1], 0);
            delay(x);
        }
        for (int i = 0; i < 4; i++)
        {
            digitalWrite(layer[i], 1);
            delay(x);
        }
        for (int i = 0; i < 4; i++)
        {
            digitalWrite(layer[i], 0);
            delay(x);
        }
        for (int i = 4; i != 0; i--)
        {
            digitalWrite(layer[i - 1], 1);
            delay(x);
        }
    }
}

void turnOnAndOffAllByColumnSideways()
{
    int x = 75;
    turnEverythingOff();

    for (int i = 0; i < 4; i++)
    {
        digitalWrite(layer[i], 1);
    }
    for (int y = 0; y < 3; y++)
    {

        for (int i = 0; i < 4; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 4; i < 8; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 8; i < 12; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 12; i < 16; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 0; i < 4; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }

        for (int i = 4; i < 8; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }

        for (int i = 8; i < 12; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }

        for (int i = 12; i < 16; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }

        for (int i = 12; i < 16; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 8; i < 12; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 4; i < 8; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 0; i < 4; i++)
        {
            digitalWrite(column[i], 0);
            delay(x);
        }

        for (int i = 12; i < 16; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }

        for (int i = 8; i < 12; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }

        for (int i = 4; i < 8; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }

        for (int i = 0; i < 4; i++)
        {
            digitalWrite(column[i], 1);
            delay(x);
        }
    }
}

void layerstompUpAndDown()
{
    int x = 75;
    for (int i = 0; i < 4; i++)
    {
        digitalWrite(layer[i], 0);
    }
    for (int y = 0; y < 5; y++)
    {
        for (int count = 0; count < 1; count++)
        {
            for (int i = 0; i < 4; i++)
            {
                digitalWrite(layer[i], 1);
                delay(x);
                digitalWrite(layer[i], 0);
            }
            for (int i = 4; i != 0; i--)
            {
                digitalWrite(layer[i - 1], 1);
                delay(x);
                digitalWrite(layer[i - 1], 0);
            }
        }
        for (int i = 0; i < 4; i++)
        {
            digitalWrite(layer[i], 1);
            delay(x);
        }
        for (int i = 4; i != 0; i--)
        {
            digitalWrite(layer[i - 1], 0);
            delay(x);
        }
    }
}

void flickerOff()
{
    turnEverythingOn();
    for (int i = 0; i != 150; i += 5)
    {
        turnEverythingOff();
        delay(i + 50);
        turnEverythingOn();
        delay(i);
    }
}

void aroundEdgeDown()
{
    for (int x = 200; x != 0; x -= 50)
    {
        turnEverythingOff();
        for (int i = 4; i != 0; i--)
        {
            digitalWrite(layer[i - 1], 1);
            digitalWrite(column[5], 0);
            digitalWrite(column[6], 0);
            digitalWrite(column[9], 0);
            digitalWrite(column[10], 0);

            digitalWrite(column[0], 0);
            delay(x);
            digitalWrite(column[0], 1);
            digitalWrite(column[4], 0);
            delay(x);
            digitalWrite(column[4], 1);
            digitalWrite(column[8], 0);
            delay(x);
            digitalWrite(column[8], 1);
            digitalWrite(column[12], 0);
            delay(x);
            digitalWrite(column[12], 1);
            digitalWrite(column[13], 0);
            delay(x);
            digitalWrite(column[13], 1);
            digitalWrite(column[15], 0);
            delay(x);
            digitalWrite(column[15], 1);
            digitalWrite(column[14], 0);
            delay(x);
            digitalWrite(column[14], 1);
            digitalWrite(column[11], 0);
            delay(x);
            digitalWrite(column[11], 1);
            digitalWrite(column[7], 0);
            delay(x);
            digitalWrite(column[7], 1);
            digitalWrite(column[3], 0);
            delay(x);
            digitalWrite(column[3], 1);
            digitalWrite(column[2], 0);
            delay(x);
            digitalWrite(column[2], 1);
            digitalWrite(column[1], 0);
            delay(x);
            digitalWrite(column[1], 1);
        }
    }
}

void randomflicker()
{
    turnEverythingOff();
    int x = 10;
    for (int i = 0; i != 750; i += 2)
    {
        int randomLayer = random(0, 4);
        int randomColumn = random(0, 16);

        digitalWrite(layer[randomLayer], 1);
        digitalWrite(column[randomColumn], 0);
        delay(x);
        digitalWrite(layer[randomLayer], 0);
        digitalWrite(column[randomColumn], 1);
        delay(x);
    }
}

void randomRain()
{
    turnEverythingOff();
    int x = 100;
    for (int i = 0; i != 60; i += 2)
    {
        int randomColumn = random(0, 16);
        digitalWrite(column[randomColumn], 0);
        digitalWrite(layer[0], 1);
        delay(x + 50);
        digitalWrite(layer[0], 0);
        digitalWrite(layer[1], 1);
        delay(x);
        digitalWrite(layer[1], 0);
        digitalWrite(layer[2], 1);
        delay(x);
        digitalWrite(layer[2], 0);
        digitalWrite(layer[3], 1);
        delay(x + 50);
        digitalWrite(layer[3], 0);
        digitalWrite(column[randomColumn], 1);
    }
}

void diagonalRectangle()
{
    int x = 350;
    turnEverythingOff();
    for (int count = 0; count < 5; count++)
    {

        for (int i = 0; i < 8; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[3], 1);
        digitalWrite(layer[2], 1);
        delay(x);
        turnEverythingOff();

        for (int i = 4; i < 12; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[1], 1);
        digitalWrite(layer[2], 1);
        delay(x);
        turnEverythingOff();

        for (int i = 8; i < 16; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[0], 1);
        digitalWrite(layer[1], 1);
        delay(x);
        turnEverythingOff();

        for (int i = 4; i < 12; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[0], 1);
        digitalWrite(layer[1], 1);
        delay(x);
        turnEverythingOff();

        for (int i = 0; i < 8; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[0], 1);
        digitalWrite(layer[1], 1);
        delay(x);
        turnEverythingOff();

        for (int i = 4; i < 12; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[1], 1);
        digitalWrite(layer[2], 1);
        delay(x);
        turnEverythingOff();

        for (int i = 8; i < 16; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[2], 1);
        digitalWrite(layer[3], 1);
        delay(x);
        turnEverythingOff();

        for (int i = 4; i < 12; i++)
        {
            digitalWrite(column[i], 0);
        }
        digitalWrite(layer[2], 1);
        digitalWrite(layer[3], 1);
        delay(x);
        turnEverythingOff();
    }

    for (int i = 0; i < 8; i++)
    {
        digitalWrite(column[i], 0);
    }
    digitalWrite(layer[3], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
}

void propeller()
{
    turnEverythingOff();
    int x = 90;
    for (int y = 4; y > 0; y--)
    {
        for (int i = 0; i < 6; i++)
        {

            digitalWrite(layer[y - 1], 1);

            turnColumnsOff();
            digitalWrite(column[0], 0);
            digitalWrite(column[5], 0);
            digitalWrite(column[10], 0);
            digitalWrite(column[15], 0);
            delay(x);

            turnColumnsOff();
            digitalWrite(column[4], 0);
            digitalWrite(column[5], 0);
            digitalWrite(column[10], 0);
            digitalWrite(column[11], 0);
            delay(x);

            turnColumnsOff();
            digitalWrite(column[6], 0);
            digitalWrite(column[7], 0);
            digitalWrite(column[8], 0);
            digitalWrite(column[9], 0);
            delay(x);

            turnColumnsOff();
            digitalWrite(column[3], 0);
            digitalWrite(column[6], 0);
            digitalWrite(column[9], 0);
            digitalWrite(column[12], 0);
            delay(x);

            turnColumnsOff();
            digitalWrite(column[2], 0);
            digitalWrite(column[6], 0);
            digitalWrite(column[9], 0);
            digitalWrite(column[13], 0);
            delay(x);

            turnColumnsOff();
            digitalWrite(column[1], 0);
            digitalWrite(column[5], 0);
            digitalWrite(column[10], 0);
            digitalWrite(column[14], 0);
            delay(x);
        }
    }

    turnColumnsOff();
    digitalWrite(column[0], 0);
    digitalWrite(column[5], 0);
    digitalWrite(column[10], 0);
    digitalWrite(column[15], 0);
    delay(x);
}

void spiralInAndOut()
{
    turnEverythingOn();
    int x = 60;
    for (int i = 0; i < 6; i++)
    {

        digitalWrite(column[0], 1);
        delay(x);
        digitalWrite(column[1], 1);
        delay(x);
        digitalWrite(column[2], 1);
        delay(x);
        digitalWrite(column[3], 1);
        delay(x);
        digitalWrite(column[7], 1);
        delay(x);
        digitalWrite(column[11], 1);
        delay(x);
        digitalWrite(column[15], 1);
        delay(x);
        digitalWrite(column[14], 1);
        delay(x);
        digitalWrite(column[13], 1);
        delay(x);
        digitalWrite(column[12], 1);
        delay(x);
        digitalWrite(column[8], 1);
        delay(x);
        digitalWrite(column[4], 1);
        delay(x);
        digitalWrite(column[5], 1);
        delay(x);
        digitalWrite(column[6], 1);
        delay(x);
        digitalWrite(column[10], 1);
        delay(x);
        digitalWrite(column[9], 1);
        delay(x);

        digitalWrite(column[9], 0);
        delay(x);
        digitalWrite(column[10], 0);
        delay(x);
        digitalWrite(column[6], 0);
        delay(x);
        digitalWrite(column[5], 0);
        delay(x);
        digitalWrite(column[4], 0);
        delay(x);
        digitalWrite(column[8], 0);
        delay(x);
        digitalWrite(column[12], 0);
        delay(x);
        digitalWrite(column[13], 0);
        delay(x);
        digitalWrite(column[14], 0);
        delay(x);
        digitalWrite(column[15], 0);
        delay(x);
        digitalWrite(column[11], 0);
        delay(x);
        digitalWrite(column[7], 0);
        delay(x);
        digitalWrite(column[3], 0);
        delay(x);
        digitalWrite(column[2], 0);
        delay(x);
        digitalWrite(column[1], 0);
        delay(x);
        digitalWrite(column[0], 0);
        delay(x);

        digitalWrite(column[0], 1);
        delay(x);
        digitalWrite(column[4], 1);
        delay(x);
        digitalWrite(column[8], 1);
        delay(x);
        digitalWrite(column[12], 1);
        delay(x);
        digitalWrite(column[13], 1);
        delay(x);
        digitalWrite(column[14], 1);
        delay(x);
        digitalWrite(column[15], 1);
        delay(x);
        digitalWrite(column[11], 1);
        delay(x);
        digitalWrite(column[7], 1);
        delay(x);
        digitalWrite(column[3], 1);
        delay(x);
        digitalWrite(column[2], 1);
        delay(x);
        digitalWrite(column[1], 1);
        delay(x);
        digitalWrite(column[5], 1);
        delay(x);
        digitalWrite(column[9], 1);
        delay(x);
        digitalWrite(column[10], 1);
        delay(x);
        digitalWrite(column[6], 1);
        delay(x);

        digitalWrite(column[6], 0);
        delay(x);
        digitalWrite(column[10], 0);
        delay(x);
        digitalWrite(column[9], 0);
        delay(x);
        digitalWrite(column[5], 0);
        delay(x);
        digitalWrite(column[1], 0);
        delay(x);
        digitalWrite(column[2], 0);
        delay(x);
        digitalWrite(column[3], 0);
        delay(x);
        digitalWrite(column[7], 0);
        delay(x);
        digitalWrite(column[11], 0);
        delay(x);
        digitalWrite(column[15], 0);
        delay(x);
        digitalWrite(column[14], 0);
        delay(x);
        digitalWrite(column[13], 0);
        delay(x);
        digitalWrite(column[12], 0);
        delay(x);
        digitalWrite(column[8], 0);
        delay(x);
        digitalWrite(column[4], 0);
        delay(x);
        digitalWrite(column[0], 0);
        delay(x);
    }
}

void goThroughAllLedsOneAtATime()
{
    int x = 15;
    turnEverythingOff();
    for (int y = 0; y < 5; y++)
    {

        for (int count = 4; count != 0; count--)
        {
            digitalWrite(layer[count - 1], 1);
            for (int i = 0; i < 4; i++)
            {
                digitalWrite(column[i], 0);
                delay(x);
                digitalWrite(column[i], 1);
                delay(x);
            }
            digitalWrite(layer[count - 1], 0);
        }

        for (int count = 0; count < 4; count++)
        {
            digitalWrite(layer[count], 1);
            for (int i = 4; i < 8; i++)
            {
                digitalWrite(column[i], 0);
                delay(x);
                digitalWrite(column[i], 1);
                delay(x);
            }
            digitalWrite(layer[count], 0);
        }

        for (int count = 4; count != 0; count--)
        {
            digitalWrite(layer[count - 1], 1);
            for (int i = 8; i < 12; i++)
            {
                digitalWrite(column[i], 0);
                delay(x);
                digitalWrite(column[i], 1);
                delay(x);
            }
            digitalWrite(layer[count - 1], 0);
        }

        for (int count = 0; count < 4; count++)
        {
            digitalWrite(layer[count], 1);
            for (int i = 12; i < 16; i++)
            {
                digitalWrite(column[i], 0);
                delay(x);
                digitalWrite(column[i], 1);
                delay(x);
            }
            digitalWrite(layer[count], 0);
        }
    }
}

---

더 있으면 좋은 기능

 

저는 LED CUBE를 무선으로 전원공급을 하기 위해서 7V 건전지 2개를 사용해서 외부전원을 넣었습니다. 

외부전원은 배터리홀더의 선중 빨간 선은 VIN 검은선은 GND에 꽃아 주면 쉽게 만들 수 있다.

---

사진 및 시연

 

LED CUBE 4X4X4.mp4

18.27MB

---

완성

 

코드는 Github에서도 보실 수 있습니다.

Github : https://github.com/dongwookkim3/LED_CUBE-arduino

GitHub - dongwookkim3/LED_CUBE-arduino