¡Hola amigos! Teníamos pendiente en nuestra lista de proyectos construir un cubo de leds y finalmente nos pusimos manos a la obra. Optamos por hacer un cubo de 4x4x4, que incluye un total de 64 leds blancos que teníamos disponibles.

La construcción de estos cubos es un proyecto muy interesante para un fin de semana, ya que no solo son agradables a la vista, sino que también tienen muchas posibilidades de experimentación con la programación mediante el uso de arduino. Con estos cubos, podemos representar diferentes formas y efectos de luz con un efecto 3D impresionante.

Existen distintas variedades de cubos de leds, como los de 3x3x3, 8x8x8 y muchos más, que se pueden hacer con leds de diferentes colores o incluso con leds RGB.

¡Anímate a construir tu propio cubo de leds! Es una actividad creativa y entretenida que seguramente te dejará satisfecho con los resultados.

Al aumentar la cantidad de leds en el cubo, también aumenta la complejidad del circuito de control y de la programación. Por lo tanto, decidimos construir un cubo de leds de 4x4x4, que se puede ensamblar en un fin de semana y es bastante interesante.

Para el cerebro del cubo de leds, utilizamos un Arduino Mega 2560, aunque se puede utilizar Arduino UNO o Arduino Nano sin ningún problema.

Para la construcción del cubo, necesitamos 64 leds de cualquier color, además de algunos extras por si cometemos algún error. También requerimos 16 resistencias de 220 ohmios y 4 resistencias de 10k. Además, se necesitan 4 transistores 2n2222 o algún otro transistor de propósito general, uno por cada piso de leds (en este caso, 4 pisos). Finalmente, se requiere una protoboard y cables de colores.

El primer paso para la construcción del cubo es armar cada piso soldando los leds unos a otros. Cada piso consta de 16 leds, y en cada piso, todos los terminales negativos de los 16 leds (o cátodos) se unen o sueldan juntos, mientras que los pines correspondientes a los positivos o ánodos quedan libres. Luego, unimos los pines positivos a sus correspondientes en el piso superior. Es decir, el led número 1 debe tener su pin positivo soldado junto al pin positivo del led 1 del piso superior, y así sucesivamente.

Para facilitar la comprensión, te dejamos la siguiente imagen explicativa.

Al final del armado del cubo, deberíamos tener 4 terminales negativos, uno por cada piso, y 16 terminales positivos o ánodos. Cada terminal negativo será controlado mediante los 4 transistores y cada terminal positivo será manejado por las salidas digitales del Arduino.

Por lo tanto, si deseamos encender el led 1 del piso 2, debemos activar el correspondiente transistor para enviar a tierra el terminal negativo de ese piso y, al mismo tiempo, encender la salida correspondiente a los leds 1 del cubo.

Para obtener un cubo de aspecto limpio y prolijo, les recomiendo utilizar la siguiente plantilla que, además de indicarnos en qué dirección debemos doblar las patas de cada led para poder soldarlas, nos ayuda a mantener la proporción adecuada entre los leds soldados.

Si deseamos que nuestro cubo tenga un aspecto prolijo y ordenado, se recomienda utilizar una plantilla que nos indique la dirección en que deben doblarse las patas de cada led para soldarlos de forma uniforme. En la plantilla, las flechas azules indican los terminales positivos de cada led, mientras que las flechas rojas indican la dirección en que se debe doblar la pata negativa de cada led.

Podemos mejorar el texto de la siguiente manera:

Luego de armar cada piso de manera individual, será necesario unirlos para finalmente tener nuestro cubo de leds completo.

A continuación, procederemos a armar el circuito en nuestra protoboard, siguiendo el esquema que se muestra en la imagen siguiente.

Para concluir, solo queda cargar el programa correspondiente al arduino. Al final del post se encuentra el código que debemos subir. Una vez cargado, podemos disfrutar de nuestro cubo de leds en pleno funcionamiento.

Les dejo a continuación un video de nuestro cubo led en acción.

 

int layer[4]={A3,A2,A1,A0}; 
//initializing and declaring led layers
int column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4};
//initializing and declaring led rows
int time = 250; void setup()
{
  for(int i = 0; i<16; i++)
  { 
    pinMode(column[i], OUTPUT); //setting rows to ouput
  } 
  for(int i = 0; i<4; i++)
  { 
    pinMode(layer[i], OUTPUT); //setting layers to output
  }
  randomSeed(analogRead(10)); //seeding random for random pattern
  } 
  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); 
    } 
    
  //turn all off 
  void turnEverythingOff() 
  { 
    for(int i = 0; i<16; i++) 
    { digitalWrite(column[i], 1); 
    } for(int i = 0; i<4; i++) 
    { digitalWrite(layer[i], 0); 
    } 
   } 
   //turn all on 
   void turnEverythingOn() 
   { 
    for(int i = 0; i<16; i++) 
    { digitalWrite(column[i], 0); 
    } 
    //turning on layers 
    for(int i = 0; i<4; i++) 
    {
      digitalWrite(layer[i], 1);
      } 
      } 
      //turn columns off 
      void turnColumnsOff() 
      { for(int i = 0; i<16; i++) 
      { 
        digitalWrite(column[i], 1); 
        } 
        } 
        //flicker on 
        void flickerOn() 
        { int i = 150; 
        while(i != 0) 
        { 
          turnEverythingOn(); 
          delay(i); 
          turnEverythingOff(); 
          delay(i); 
          i-= 5; 
          } 
          } 
          //turn everything on and off by layer up and down NOT TIMED 
          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);
        } 
        } 
        } 
        //turn everything on and off by column sideways
        void turnOnAndOffAllByColumnSideways() 
        { 
          int x = 75; 
          turnEverythingOff(); 
          //turn on layers 
          for(int i = 0; i<4; i++) 
          { 
            digitalWrite(layer[i], 1);
            } 
            for(int y = 0; y<3; y++) 
            { 
              //turn on 0-3 
              for(int i = 0; i<4; i++)
              { 
                digitalWrite(column[i], 0);
                delay(x);
                }
                //turn on 4-7 
                for(int i = 4; i<8; i++)
                { 
                  digitalWrite(column[i], 0);
                  delay(x);
                  } 
                  //turn on 8-11
                  for(int i = 8; i<12; i++)
                  { 
                    digitalWrite(column[i], 0);
                    delay(x);
                    }
                    //turn on 12-15
  for(int i = 12; i<16; i++)
  {
    digitalWrite(column[i], 0);
    delay(x);
    } 
    //turn off 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
      } 
      //turn off 4-7 
      for(int i = 4; i<8; i++)
      { 
        digitalWrite(column[i], 1);
        delay(x);
        } 
        //turn off 8-11
        for(int i = 8; i<12; i++)
        { 
          digitalWrite(column[i], 1);
          delay(x);
          } 
          //turn off 12-15
          for(int i = 12; i<16; i++)
          {
            digitalWrite(column[i], 1);
            delay(x);
            } 
            //turn on 12-15
            for(int i = 12; i<16; i++)
            { 
              digitalWrite(column[i], 0);
              delay(x);
              }
              //turn on 8-11
              for(int i = 8; i<12; i++)
              { 
                digitalWrite(column[i], 0);
                delay(x);
                } 
                //turn on 4-7
                for(int i = 4; i<8; i++)
                {
  digitalWrite(column[i], 0);
  delay(x); 
  } 
  //turn on 0-3 
  for(int i = 0; i<4; i++) 
  { 
    digitalWrite(column[i], 0); 
    delay(x);
    } 
    //turn off 12-15
    for(int i = 12; i<16; i++)
    { 
      digitalWrite(column[i], 1);
      delay(x); } 
      //turn off 8-11
      for(int i = 8; i<12; i++)
      { 
        digitalWrite(column[i], 1); 
        delay(x); 
        } 
        //turn off 4-7 
        for(int i = 4; i<8; i++) 
        { 
          digitalWrite(column[i], 1); 
          delay(x); 
          } //turn off 0-3
          for(int i = 0; i<4; i++) 
          { 
            digitalWrite(column[i], 1);
            delay(x); 
            } 
            } 
            } 
            //up and down single layer stomp
            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); 
                        } 
                        } 
                        } 
                        //flicker off 
                        void flickerOff() 
                        { 
                          turnEverythingOn(); 
                          for(int i = 0; i!= 150; i+=5) 
                          { 
                            turnEverythingOff(); 
                            delay(i+50); turnEverythingOn(); 
                            delay(i); 
                            } 
                            } 
                            //around edge of the cube down 
                            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); 
             } 
             } 
             } 
             //random flicker 
             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); 
                } 
                } 
                //random rain 
                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); 
                    }
                    } 
                    //diagonal rectangle 
                    void diagonalRectangle() 
                    {
                      int x = 350; 
                      turnEverythingOff(); 
                      for(int count = 0; count<5; count++) 
                      { 
                        //top left 
                        for(int i = 0; i<8; i++) 
                        { 
                          digitalWrite(column[i], 0); 
                          }
                digitalWrite(layer[3], 1); 
                digitalWrite(layer[2], 1); 
                delay(x); 
                turnEverythingOff(); 
                //middle middle 
                for(int i = 4; i<12; i++) 
                { 
                  
                digitalWrite(column[i], 0); 
                  
               } 
                  digitalWrite(layer[1], 1);    
                  digitalWrite(layer[2], 1); 
                  delay(x); 
                  turnEverythingOff(); 
                  //bottom right 
                  for(int i = 8; i<16; i++) 
                  { 
                    digitalWrite(column[i], 0); 
                    } 
                    digitalWrite(layer[0], 1); 
                    digitalWrite(layer[1], 1); 
                    delay(x); 
                    turnEverythingOff(); 
                    //bottom middle 
                    for(int i = 4; i<12; i++) 
                    { 
                      digitalWrite(column[i], 0); 
                      } 
                      digitalWrite(layer[0], 1);     
                      digitalWrite(layer[1], 1); 
                      delay(x); 
                      turnEverythingOff(); 
                      //bottom left 
                      for(int i = 0; i<8; i++) 
                      { 
                        digitalWrite(column[i], 0); 
                        } 
                        digitalWrite(layer[0], 1); 
                        digitalWrite(layer[1], 1); 
                        delay(x); 
                        turnEverythingOff(); 
                        //middle middle 
                        for(int i = 4; i<12; i++) 
                        { 
                          digitalWrite(column[i], 0); 
                          } 
                          digitalWrite(layer[1], 1);     
                          digitalWrite(layer[2], 1); 
                          delay(x); 
                          turnEverythingOff(); 
                          //top right
                          for(int i = 8; i<16; i++) 
                          { 
                            digitalWrite(column[i], 0); 
                            } 
                            digitalWrite(layer[2], 1); 
                            digitalWrite(layer[3], 1); 
                            delay(x); 
                            turnEverythingOff(); 
                            //top middle 
                            for(int i = 4; i<12; i++) 
                            { 
                              digitalWrite(column[i], 0); 
                              } 
                              digitalWrite(layer[2], 1); 
                              digitalWrite(layer[3], 1); 
                              delay(x); 
                              turnEverythingOff(); 
                              } 
                              //top left 
                              for(int i = 0; i<8; i++) 
                              { 
                                digitalWrite(column[i], 0); 
                                } 
                                digitalWrite(layer[3], 1); 
                                digitalWrite(layer[2], 1); 
                                delay(x); 
                                turnEverythingOff(); 
                                } 
                                //propeller 
             void propeller() 
             { 
              turnEverythingOff(); 
              int x = 90; 
              for(int y = 4; y>0; y--)
              { 
                for(int i = 0; i<6; i++) 
                { 
                  //turn on layer
                  digitalWrite(layer[y-1], 1); 
                  //a1 
                  turnColumnsOff(); 
                  digitalWrite(column[0], 0); 
                  digitalWrite(column[5], 0); 
                  digitalWrite(column[10], 0); 
                  digitalWrite(column[15], 0); 
                  delay(x); 
                  //b1 
                  turnColumnsOff(); 
                  digitalWrite(column[4], 0); 
                  digitalWrite(column[5], 0); 
                  digitalWrite(column[10], 0); 
                  digitalWrite(column[11], 0); 
                  delay(x); 
                  //c1 
                  turnColumnsOff(); 
                  digitalWrite(column[6], 0); 
                  digitalWrite(column[7], 0); 
                  digitalWrite(column[8], 0); 
                  digitalWrite(column[9], 0); 
                  delay(x); 
                  //d1 
                  turnColumnsOff(); 
                  digitalWrite(column[3], 0); 
                  digitalWrite(column[6], 0); 
                  digitalWrite(column[9], 0); 
                  digitalWrite(column[12], 0); 
                  delay(x); 
                  //d2 
                  turnColumnsOff(); 
                  digitalWrite(column[2], 0); 
                  digitalWrite(column[6], 0); 
                  digitalWrite(column[9], 0); 
                  digitalWrite(column[13], 0);
                  delay(x); 
                  //d3 
                  turnColumnsOff(); 
                  digitalWrite(column[1], 0); 
                  digitalWrite(column[5], 0); 
                  digitalWrite(column[10], 0); 
                  digitalWrite(column[14], 0); 
                  delay(x); 
                  } 
                  } 
                  //d4 
                  turnColumnsOff(); 
                  digitalWrite(column[0], 0); 
                  digitalWrite(column[5], 0); 
                  digitalWrite(column[10], 0); 
                  digitalWrite(column[15], 0); 
                  delay(x); 
                  } 
                  //spiral in and out
                  void spiralInAndOut() 
                  { 
                    turnEverythingOn(); 
                    int x = 60; 
                    for(int i = 0; i<6; i++) 
                    { 
                      //spiral in clockwise
                      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); 
                      //spiral out counter clockwise 
                      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); 
                      //spiral in counter clock wise 
                      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); 
                      //spiral out clock wise 
                      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); 
                      } 
                      } 
                      //go through all leds one at a time 
                      void goThroughAllLedsOneAtATime() 
                      { 
                      int x = 15; 
                        turnEverythingOff(); 
                        for(int y = 0; y<5; y++) 
                        { 
                          //0-3 
                 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); 
                              } 
                              //4-7 
                   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); 
                                  } 
                                  //8-11 
       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); 
                                      } 
                                  //12-15 
                        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); 
                                          } 
                                          } 
                                          }
         

Para finalizar, espero que este tutorial les haya sido útil y que se hayan animado a construir su propio cubo de LEDs. Es un proyecto divertido y educativo que puede ser personalizado y modificado según sus preferencias y habilidades. Además, con un poco de creatividad, se pueden crear efectos impresionantes y únicos con este cubo de LEDs. No olviden compartir sus resultados y experimentos con nosotros. ¡A divertirse!