sexta-feira, 30 de dezembro de 2016

Cubo de LEDs

LEDs




Os componentes semi-condutores, ficam em uma situação intermediária entre os condutores e os isolantes, e essa situação pode ser alterada conforme o processo adotado (contaminação ou dopagem).
Graças a suas características os materiais semi-condutores são a base do funcionamento de diodos e aí encaixa-se os LEDs, que são diodos emissores de luz (LED - light emitter diode).


fonte: http://www.e360.es

É um componente do tipo bipolar, constituídos por lados distintos denominados anodo e catodo.


fonte: wikipidia

Assim como os diodos, os LEDs trabalha conforme a sua polarização, permitindo ou não a passagem da corrente elétrica e consequentemente transformando-a em luz, resultado possível graças ao componente principal do LED, o chip semicondutor.


fonte: https://www.electronica-pt.com/led

Nos exemplos estamos falando de LEDs convencionais, encontrados facilmente em qualquer loja de eletrônicos da cidade.

Inventado em 1963 por Nick Holonyac, tinha baixa intensidade luminosa e somente uma cor, a vermelha, e utilizado para indicação de estado dos aparelhos, demonstrava visualmente quando um equipamento encontrava-se ligado ou desligado. No final dos anos 60, foi introduzido no mercado o LED amarelo e somente por volta de 1975 surgiu o LED verde.
As possibilidades de substituição de lâmpadas convencionais por LEDs só começou a tornar possível durante os anos 80, quando a tecnologia Al In GaP possibilitou que LEDs vermelhos e âmbar atingissem melhores níveis de intensidade luminosa. No início dos anos 90, com o surgimento da tecnologia InGaN, as possibilidades aumentaram e as famílias de LEDs ganharam proporção com as cores azul, verde e ciano, até a obtenção do LED branco e consequentemente todo aspecto de cores, e no final dos anos 90 juntamente com o final da década veio o primeiro LED com tecnologia Luxeon, uma revolução na tecnologia desse componente que não tratava-se mais de produzir intensidade luminosa, passando a se tratar de fluxo luminoso, na ordem de 30 a 40 lumens.

fonte: http://www.directlight.com.br/perfil/sobre-led/

Atualmente os LEDs atingem a marca de 120 lumens de fluxo luminoso e com potência que varia de 1 à 5 watts.

Curiosidades sobre os LEDs

  • Dependendo da aplicação do LED, sua vida útil é bem longa, dependendo de uma manutenção mínima depois de 50.000 horas;
  • Baixíssima manutenção;
  • Trabalho com tensões baixas, sem oferecer risco ao usuário;
  • Ecologicamente correto, não utiliza mercúrio, que causa dano à natureza.

O cubo de LED


Utilizando esse componente, basta uma rápida pesquisa no Google para encontrarmos uma infinidade de equipamentos que fazem uso do LED para diferentes funções. Um dos equipamentos montados com ele que é muito interessante, pois além de bonito, requer programação microcontrolada é o Cubo de LED, é possível realizar a construção desses "ornamentos" de diversos tipos e tamanhos.

Cubo de LED 4x4x4


Vou apresentar um cubo de LED 4x4 passo a passo para que seja possível sua construção. Para esse projeto você vai precisar de:

1 Arduino Uno ( ou similar)
4 resistore 100 ohms
64 LEDs ( da cor que preferir)
1 placa universal perfurada (eu utilizei uma 14x10 cm, mas pode ser de sua preferência)
1 botão ON/OFF (opcional)
1 LED indicador de funcionamento (opcional)
1 resistor 220 ohms (opcional)
1 conector Jack (opcional)
1 fonte externa 1A
fio de cobre estanhado (tipo cabo fi 0,6mm - cabo de telefonia)

A elaboração da caixa para o circuito ou a estrutura do cubo pode ser feita como preferir, eu utilizei pedaços de acrílico de aproximadamente 10x10 cm, com insulfilm no interior.

Construção da torre de LEDs - camadas


As "camadas" de LEDs foram montadas utilizando um gabarito conforme a figura.





fonte: próprio autor

As distâncias devem ser feitas de maneira que um catodo do LED consiga alcançar o catodo do outro para que seja inserido solda ligando-os.



fonte: próprio autor

Durante a montagem, é importante observar um leve grau no anodo permitindo que as camadas possam ser "empilhadas".








fonte: próprio autor

 Elaborar furações na caixa de maneira que os anodos (sustentação) dos LEDs passem pela caixa de apoio.


fonte: próprio autor




fonte: próprio autor

Inserir com cuidado todos os anodos na placa por baixo do suporte e soldar, pode-se fixar também a placa no suporte utilizando cola quente.



fonte: próprio autor

Esquema de ligação


O esquema de ligação está separado em camadas então deve-se ter bastante atenção na hora de ligá-los com solda.


fonte: próprio autor


fonte: próprio autor

Finalizado conforme desejar, agora vamos trabalhar o código fonte para a sequencia dos LEDs.

O código fonte 


Foi elaborado alguns movimentos com os LEDs dentro do Cubo, podendo ser alterados conforme a necessidade do usuário. Para testar o projeto, copie e cole o código na IDE do Arduino.

/*
 //** Código **/
// Elaborado por Tony Emerson Marim em 30/12/2016.
/** mecatronizando@gmail.com **/ 
/* 4x4x4 CUBO DE LED
  Configurar : 
  Colunas
  [(x,y)-Pin]
  (1,1)-13
  (1,2)-12
  (1,3)-11
  (1,4)-10
  (2,1)-9
  (2,2)-8
  (2,3)-7
  (2,4)-6
  (3,1)-5
  (3-2)-4
  (3-3)-3
  (3,4)-2
  (4,1)-1
  (4,2)-0
  (4,3)-A5
  (4,4)-A4
  Camadas
  [camada-Pin]
  a-A0
  b-A1
  c-A2
  d-A3
*/
//Declaração das colunas de LEDs
  int coluna[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4};
//Declaração das camadas de LEDs
  int camada[4]={A3,A2,A1,A0};

  int time = 250;
 
void setup()
{
  //Configurar coluna de saída
  for(int i = 0; i<16; i++)
  {
    pinMode(coluna[i], OUTPUT);
  }
  //Configurar camadas
  for(int i = 0; i<4; i++)
  {
    pinMode(camada[i], OUTPUT);
  }
  //Padrão aleatório
  randomSeed(analogRead(10));
}

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

///////////////////////////////////////////////////////////Desliga tudo
void turnEverythingOff()
 {
   for(int i = 0; i<16; i++)
   {
     digitalWrite(coluna[i], 1);
   }
   for(int i = 0; i<4; i++)
   {
     digitalWrite(camada[i], 0);
   }
 }
 
////////////////////////////////////////////////////////////Liga tudo
void turnEverythingOn()
{
  for(int i = 0; i<16; i++)
  {
    digitalWrite(coluna[i], 0);
  }
  //turning on layers
  for(int i = 0; i<4; i++)
  {
    digitalWrite(camada[i], 1);
  }
}
///////////////////////////////////////////////////////Desliga colunas
void turnColumnsOff()
{
  for(int i = 0; i<16; i++)
  {
    digitalWrite(coluna[i], 1);
  }
}
/////////////////////////////////////////////////////////////Liga Agito
void flickerOn()
{
  int i = 150;
  while(i != 0)
  {
    turnEverythingOn();
    delay(i);
    turnEverythingOff();
    delay(i);
    i-= 5;
  }
}
//////////////Ativar e desativar tudo por camada para cima e para baixo
void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
  int x = 75;
  for(int i = 5; i != 0; i--)
  {
    turnEverythingOn();
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(camada[i-1], 0);
      delay(x);
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(camada[i], 1);
      delay(x);
    }
      for(int i = 0; i<4; i++)
    {
      digitalWrite(camada[i], 0);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(camada[i-1], 1);
      delay(x);
    }
  }
}
//////////////////////////Ligar e desligar tudo pela coluna lateralmente
void turnOnAndOffAllByColumnSideways()
{
  int x = 75;
  turnEverythingOff();
  //Liga as colunas
  for(int i = 0; i<4; i++)
  {
    digitalWrite(camada[i], 1);
  }
  for(int y = 0; y<3; y++)
  {
    //Ligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Desligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Ligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Ligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 0);
      delay(x);
    }
    //Desligar 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
    //Desligar 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(coluna[i], 1);
      delay(x);
    }
  }
}
/////////////////////////////////////////Subir e descer coluna em espiral
void layerstompUpAndDown()
{
  int x = 75;
  for(int i = 0; i<4; i++)
  {
    digitalWrite(camada[i], 0);
  }
  for(int y = 0; y<5; y++)
  {
    for(int count = 0; count<1; count++)
    { 
      for(int i = 0; i<4; i++)
      {
        digitalWrite(camada[i], 1);
        delay(x);
        digitalWrite(camada[i], 0);
      }
      for(int i = 4; i !=0; i--)
      {
        digitalWrite(camada[i-1], 1);
        delay(x);
        digitalWrite(camada[i-1], 0);
      }
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(camada[i], 1);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(camada[i-1], 0);
      delay(x);
    }
  }
}
////////////////////////////////////////////////////////////Desligar Pisca
void flickerOff()
{
  turnEverythingOn();
  for(int i = 0; i!= 150; i+=5)
  {
    turnEverythingOff();
    delay(i+50);
    turnEverythingOn();
    delay(i);
  }
}
///////////////////////////////////////////Espiral para baixo
void aroundEdgeDown()
{
  for(int x = 200; x != 0; x -=50)
  {
    turnEverythingOff();
    for(int i = 4; i != 0; i--)
    {
      digitalWrite(camada[i-1], 1);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[9], 0);
      digitalWrite(coluna[10], 0);
      
      digitalWrite(coluna[0], 0);
      delay(x);
      digitalWrite(coluna[0], 1);
      digitalWrite(coluna[4], 0);
      delay(x);
      digitalWrite(coluna[4], 1);
      digitalWrite(coluna[8], 0);
      delay(x);
      digitalWrite(coluna[8], 1);
      digitalWrite(coluna[12], 0);
      delay(x);
      digitalWrite(coluna[12], 1);
      digitalWrite(coluna[13], 0);
      delay(x);
      digitalWrite(coluna[13], 1);
      digitalWrite(coluna[15], 0);
      delay(x);
      digitalWrite(coluna[15], 1);
      digitalWrite(coluna[14], 0);
      delay(x);
      digitalWrite(coluna[14], 1);
      digitalWrite(coluna[11], 0);
      delay(x);
      digitalWrite(coluna[11], 1);
      digitalWrite(coluna[7], 0);
      delay(x);
      digitalWrite(coluna[7], 1);
      digitalWrite(coluna[3], 0);
      delay(x);
      digitalWrite(coluna[3], 1);
      digitalWrite(coluna[2], 0);
      delay(x);
      digitalWrite(coluna[2], 1);
      digitalWrite(coluna[1], 0);
      delay(x);
      digitalWrite(coluna[1], 1);
    }
  }
}
/////////////////////////////////////////////////////////Pisca aleatório
void randomflicker()
{
  turnEverythingOff();
  int x = 10;
  for(int i = 0; i !=750; i+=2)
  {
  int randomcamada = random(0,4);
  int randomcoluna = random(0,16);
  
  digitalWrite(camada[randomcamada], 1);
  digitalWrite(coluna[randomcoluna], 0);
  delay(x);
  digitalWrite(camada[randomcamada], 0);
  digitalWrite(coluna[randomcoluna], 1);
  delay(x); 
  }
}
////////////////////////////////////////////////////////////Gotas caindo
void randomRain()
{
  turnEverythingOff();
  int x = 100;
  for(int i = 0; i!=60; i+=2)
  {
    int randomcoluna = random(0,16);
    digitalWrite(coluna[randomcoluna], 0);
    digitalWrite(camada[0], 1);
    delay(x+50);
    digitalWrite(camada[0], 0);
    digitalWrite(camada[1], 1);
    delay(x);
    digitalWrite(camada[1], 0);
    digitalWrite(camada[2], 1);
    delay(x);
    digitalWrite(camada[2], 0);
    digitalWrite(camada[3], 1);
    delay(x+50);
    digitalWrite(camada[3], 0);
    digitalWrite(coluna[randomcoluna], 1);
  }
}
/////////////////////////////////////////////////////Diagonal
void diagonalRectangle()
{
  int x = 350;
  turnEverythingOff();
  for(int count = 0; count<5; count++)
  {
    //top left
    for(int i = 0; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[3], 1);
    digitalWrite(camada[2], 1);
    delay(x);
    turnEverythingOff();
    //medio
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[1], 1);
    digitalWrite(camada[2], 1);
    delay(x);
    turnEverythingOff();
    //Centro baixo
    for(int i = 8; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[0], 1);
    digitalWrite(camada[1], 1);
    delay(x);
    turnEverythingOff();
    //Meio baixo
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[0], 1);
    digitalWrite(camada[1], 1);
    delay(x);
    turnEverythingOff();
    //Centro esquerda
    for(int i = 0; i<8; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[0], 1);
    digitalWrite(camada[1], 1);
    delay(x);
    turnEverythingOff();
    //Centro
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[1], 1);
    digitalWrite(camada[2], 1);
    delay(x);
    turnEverythingOff();
    //Alto direita
    for(int i = 8; i<16; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[2], 1);
    digitalWrite(camada[3], 1);
    delay(x);
    turnEverythingOff();
    //Alto centro
    for(int i = 4; i<12; i++)
    {
      digitalWrite(coluna[i], 0);
    }
    digitalWrite(camada[2], 1);
    digitalWrite(camada[3], 1);
    delay(x);
    turnEverythingOff();
  }
  //Alto esquerda
  for(int i = 0; i<8; i++)
  {
    digitalWrite(coluna[i], 0);
  }
  digitalWrite(camada[3], 1);
  digitalWrite(camada[2], 1);
  delay(x);
  turnEverythingOff();
}
//////////////////////////////////////////////////////////////Hélice
void propeller()
{
  turnEverythingOff();
  int x = 90;
  for(int y = 4; y>0; y--)
  {
    for(int i = 0; i<6; i++)
    {
      //Liga camada
      digitalWrite(camada[y-1], 1);
      //a1
      turnColumnsOff();
      digitalWrite(coluna[0], 0);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[10], 0);
      digitalWrite(coluna[15], 0);
      delay(x);
      //b1
      turnColumnsOff();
      digitalWrite(coluna[4], 0);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[10], 0);
      digitalWrite(coluna[11], 0);
      delay(x);
      //c1
      turnColumnsOff();
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[7], 0);
      digitalWrite(coluna[8], 0);
      digitalWrite(coluna[9], 0);
      delay(x);
      //d1
      turnColumnsOff();
      digitalWrite(coluna[3], 0);
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[9], 0);
      digitalWrite(coluna[12], 0);
      delay(x);
      //d2
      turnColumnsOff();
      digitalWrite(coluna[2], 0);
      digitalWrite(coluna[6], 0);
      digitalWrite(coluna[9], 0);
      digitalWrite(coluna[13], 0);
      delay(x);
      //d3
      turnColumnsOff();
      digitalWrite(coluna[1], 0);
      digitalWrite(coluna[5], 0);
      digitalWrite(coluna[10], 0);
      digitalWrite(coluna[14], 0);
      delay(x);
    }
  }
  //d4
  turnColumnsOff();
  digitalWrite(coluna[0], 0);
  digitalWrite(coluna[5], 0);
  digitalWrite(coluna[10], 0);
  digitalWrite(coluna[15], 0);
  delay(x);
}
//////////////////////////////////////////////////////Espiral para fora
void spiralInAndOut()
{
  turnEverythingOn();
  int x = 60;
  for(int i = 0; i<6; i++)
  {
    //spiral in clockwise
    digitalWrite(coluna[0], 1);
    delay(x);
    digitalWrite(coluna[1], 1);
    delay(x);
    digitalWrite(coluna[2], 1);
    delay(x);
    digitalWrite(coluna[3], 1);
    delay(x);
    digitalWrite(coluna[7], 1);
    delay(x);
    digitalWrite(coluna[11], 1);
    delay(x);
    digitalWrite(coluna[15], 1);
    delay(x);
    digitalWrite(coluna[14], 1);
    delay(x);
    digitalWrite(coluna[13], 1);
    delay(x);
    digitalWrite(coluna[12], 1);
    delay(x);
    digitalWrite(coluna[8], 1);
    delay(x);
    digitalWrite(coluna[4], 1);
    delay(x);
    digitalWrite(coluna[5], 1);
    delay(x);
    digitalWrite(coluna[6], 1);
    delay(x);
    digitalWrite(coluna[10], 1);
    delay(x);
    digitalWrite(coluna[9], 1);
    delay(x);
    /////////////////////////////////////// Apaga espiral anti-horário
    digitalWrite(coluna[9], 0);
    delay(x);
    digitalWrite(coluna[10], 0);
    delay(x);
    digitalWrite(coluna[6], 0);
    delay(x);
    digitalWrite(coluna[5], 0);
    delay(x);
    digitalWrite(coluna[4], 0);
    delay(x);
    digitalWrite(coluna[8], 0);
    delay(x);
    digitalWrite(coluna[12], 0);
    delay(x);
    digitalWrite(coluna[13], 0);
    delay(x);
    digitalWrite(coluna[14], 0);
    delay(x);
    digitalWrite(coluna[15], 0);
    delay(x);
    digitalWrite(coluna[11], 0);
    delay(x);
    digitalWrite(coluna[7], 0);
    delay(x);
    digitalWrite(coluna[3], 0);
    delay(x);
    digitalWrite(coluna[2], 0);
    delay(x);
    digitalWrite(coluna[1], 0);
    delay(x);
    digitalWrite(coluna[0], 0);
    delay(x);
    ///////////////////////////////////////Espiral sentido horário
    digitalWrite(coluna[0], 1);
    delay(x);
    digitalWrite(coluna[4], 1);
    delay(x);
    digitalWrite(coluna[8], 1);
    delay(x);
    digitalWrite(coluna[12], 1);
    delay(x);
    digitalWrite(coluna[13], 1);
    delay(x);
    digitalWrite(coluna[14], 1);
    delay(x);
    digitalWrite(coluna[15], 1);
    delay(x);
    digitalWrite(coluna[11], 1);
    delay(x);
    digitalWrite(coluna[7], 1);
    delay(x);
    digitalWrite(coluna[3], 1);
    delay(x);
    digitalWrite(coluna[2], 1);
    delay(x);
    digitalWrite(coluna[1], 1);
    delay(x);
    digitalWrite(coluna[5], 1);
    delay(x);
    digitalWrite(coluna[9], 1);
    delay(x);
    digitalWrite(coluna[10], 1);
    delay(x);
    digitalWrite(coluna[6], 1);
    delay(x);
    //////////////////////////////////////////////Apaga espiral no sentido horário
    digitalWrite(coluna[6], 0);
    delay(x);
    digitalWrite(coluna[10], 0);
    delay(x);
    digitalWrite(coluna[9], 0);
    delay(x);
    digitalWrite(coluna[5], 0);
    delay(x);
    digitalWrite(coluna[1], 0);
    delay(x);
    digitalWrite(coluna[2], 0);
    delay(x);
    digitalWrite(coluna[3], 0);
    delay(x);
    digitalWrite(coluna[7], 0);
    delay(x);
    digitalWrite(coluna[11], 0);
    delay(x);
    digitalWrite(coluna[15], 0);
    delay(x);
    digitalWrite(coluna[14], 0);
    delay(x);
    digitalWrite(coluna[13], 0);
    delay(x);
    digitalWrite(coluna[12], 0);
    delay(x);
    digitalWrite(coluna[8], 0);
    delay(x);
    digitalWrite(coluna[4], 0);
    delay(x);
    digitalWrite(coluna[0], 0);
    delay(x);
  }
}
//////////////////////////////////////Um LED por vez
void goThroughAllLedsOneAtATime()
{
  int x = 15;
  turnEverythingOff();
  for(int y = 0; y<5; y++)
  {
    //0-3
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(camada[count-1], 1);
      for(int i = 0; i<4; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count-1], 0);
    }
    //4-7
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(camada[count], 1);
      for(int i = 4; i<8; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count], 0);
    }
    //8-11
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(camada[count-1], 1);
      for(int i = 8; i<12; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count-1], 0);
    }
    //12-15
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(camada[count], 1);
      for(int i = 12; i<16; i++)
      {
        digitalWrite(coluna[i], 0);
        delay(x);
        digitalWrite(coluna[i], 1);
        delay(x);
      }
    digitalWrite(camada[count], 0);
    }
  }
}



No video abaixo está a demonstração do Cubo 4x4x4 montado e funcionando.



Curtiu? Compartilhe siga nossa FanPage!
Inscreva-se no canal!

Caso queira o projeto completo pode ser baixado nesse LINK!!!


Bons estudos.


Postado por às
Marcadores:

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)