Advertisement
Guest User

Untitled

a guest
Jan 30th, 2015
175
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 5.63 KB | None | 0 0
  1. /*
  2.   3x3x3 LED cube
  3.  */
  4.  
  5. //intializing and declaring layers
  6. int layer[3]={
  7.   3,4,5};
  8. //initializing and declaring leds, bottom right is led[0]
  9. int led[9]={
  10.   2,6,7,8,9,10,11,12,13};
  11.  
  12. int time = 250;
  13.  
  14. void setup()
  15. {
  16.   //setting leds to ouput
  17.   for(int i = 0; i<9; i++)
  18.   {
  19.     pinMode(led[i], OUTPUT);
  20.   }
  21.   //setting layers to output
  22.   for(int i = 0; i<3; i++)
  23.   {
  24.     pinMode(layer[i], OUTPUT);
  25.   }
  26.   //seeding random for random animations
  27.   randomSeed(analogRead(10));
  28. }
  29. //++++++++++++++MAIN FUNCTION+++++++++++
  30.  
  31. void loop()
  32. {
  33.   turnEverythingOff();//turn all off
  34.   flickerOn();
  35.   turnEverythingOn();//turn all on
  36.   delay(time);
  37.   turnOnAndOffAllByLayerUpAndDownNotTimed();
  38.   layerstompUpAndDown();
  39.   turnOnAndOffAllByColumnSideways();
  40.   delay(time);
  41.   turnEverythingOff();
  42.   randomflicker();
  43.   randomRain();
  44.   flickerOff();
  45.   turnEverythingOff();
  46.  
  47. }
  48.  
  49.  
  50. //+++++++++FUNCTIONS++++++++++
  51.  
  52. /////////turn all off
  53. void turnEverythingOff()
  54. {
  55.   for(int i = 0; i<9; i++)
  56.   {
  57.     digitalWrite(led[i], 1);
  58.   }
  59.   for(int i = 0; i<3; i++)
  60.   {
  61.     digitalWrite(layer[i], 0);
  62.   }
  63. }
  64.  
  65. //////////turn all on
  66. void turnEverythingOn()
  67. {
  68.   for(int i = 0; i<9; i++)
  69.   {
  70.     digitalWrite(led[i], 0);
  71.   }
  72.   //turning on layers
  73.   for(int i = 0; i<3; i++)
  74.   {
  75.     digitalWrite(layer[i], 1);
  76.   }
  77. }
  78. /////////////turn columns off
  79. void turnColumnsOff()
  80. {
  81.   for(int i = 0; i<9; i++)
  82.   {
  83.     digitalWrite(led[i], 1);
  84.   }
  85. }
  86. ///////////////flicker on
  87. void flickerOn()
  88. {
  89.   int i = 150;
  90.   while(i != 0)
  91.   {
  92.     turnEverythingOn();
  93.     delay(i);
  94.     turnEverythingOff();
  95.     delay(i);
  96.     i-= 5;
  97.   }
  98. }
  99. //// turn everything on and off by layer up and down NOT TIMED
  100. void turnOnAndOffAllByLayerUpAndDownNotTimed()
  101. {
  102.   int x = 75;
  103.   for(int i = 3; i != 0; i--)
  104.   {
  105.     turnEverythingOn();
  106.     for(int i = 3; i!=0; i--)
  107.     {
  108.       digitalWrite(layer[i-1], 0);
  109.       delay(x);
  110.     }
  111.     for(int i = 0; i<3; i++)
  112.     {
  113.       digitalWrite(layer[i], 1);
  114.       delay(x);
  115.     }
  116.     for(int i = 0; i<3; i++)
  117.     {
  118.       digitalWrite(layer[i], 0);
  119.       delay(x);
  120.     }
  121.     for(int i = 3; i!=0; i--)
  122.     {
  123.       digitalWrite(layer[i-1], 1);
  124.       delay(x);
  125.     }
  126.   }
  127. }
  128. //////////turn everything on and off by column sideways
  129. void turnOnAndOffAllByColumnSideways()
  130. {
  131.   int x = 75;
  132.   turnEverythingOff();
  133.   //turn on layers
  134.   for(int i = 0; i<3; i++)
  135.   {
  136.     digitalWrite(layer[i], 1);
  137.   }
  138.   for(int y = 0; y<3; y++)
  139.   {
  140.     //turn on 0-2
  141.     for(int i = 0; i<3; i++)
  142.     {
  143.       digitalWrite(led[i], 0);
  144.       delay(x);
  145.     }
  146.     //turn on 3-5
  147.     for(int i = 3; i<6; i++)
  148.     {
  149.       digitalWrite(led[i], 0);
  150.       delay(x);
  151.     }
  152.     //turn on 6-8
  153.     for(int i = 6; i<9; i++)
  154.     {
  155.       digitalWrite(led[i], 0);
  156.       delay(x);
  157.  
  158.     }
  159.     //turn off 0-2
  160.     for(int i = 0; i<3; i++)
  161.     {
  162.       digitalWrite(led[i], 1);
  163.       delay(x);
  164.     }
  165.     //turn off 3-5
  166.     for(int i = 3; i<6; i++)
  167.     {
  168.       digitalWrite(led[i], 1);
  169.       delay(x);
  170.     }
  171.     //turn off 6-8
  172.     for(int i =6 ; i<9; i++)
  173.     {
  174.       digitalWrite(led[i], 1);
  175.       delay(x);
  176.  
  177.     }
  178.     //turn on 6-8
  179.     for(int i = 6; i<9; i++)
  180.     {
  181.       digitalWrite(led[i], 0);
  182.       delay(x);
  183.     }
  184.     //turn on 3-5
  185.     for(int i = 3; i<5; i++)
  186.     {
  187.       digitalWrite(led[i], 0);
  188.       delay(x);
  189.     }
  190.     //turn on 0-2
  191.     for(int i = 0; i<3; i++)
  192.     {
  193.       digitalWrite(led[i], 0);
  194.       delay(x);
  195.  
  196.     }
  197.     //turn off 0-2
  198.     for(int i = 0; i<3; i++)
  199.     {
  200.       digitalWrite(led[i], 1);
  201.       delay(x);
  202.     }
  203.     //turn off 3-5
  204.     for(int i = 3; i<6; i++)
  205.     {
  206.       digitalWrite(led[i], 1);
  207.       delay(x);
  208.     }
  209.     //turn off 6-8
  210.     for(int i = 6; i<9; i++)
  211.     {
  212.       digitalWrite(led[i], 1);
  213.       delay(x);
  214.     }
  215.   }
  216. }
  217. ////////up and down single layer
  218. void layerstompUpAndDown()
  219. {
  220.   int x = 75;
  221.   for(int i = 0; i<3; i++)
  222.   {
  223.     digitalWrite(layer[i], 0);
  224.   }
  225.   for(int y = 0; y<4; y++)
  226.   {
  227.     for(int count = 0; count<1; count++)
  228.     {
  229.       for(int i = 0; i<3; i++)
  230.       {
  231.         digitalWrite(layer[i], 1);
  232.         delay(x);
  233.         digitalWrite(layer[i], 0);
  234.       }
  235.       for(int i = 3; i !=0; i--)
  236.       {
  237.         digitalWrite(layer[i-1], 1);
  238.         delay(x);
  239.         digitalWrite(layer[i-1], 0);
  240.       }
  241.     }
  242.     for(int i = 0; i<3; i++)
  243.     {
  244.       digitalWrite(layer[i], 1);
  245.       delay(x);
  246.     }
  247.     for(int i = 3; i!=0; i--)
  248.     {
  249.       digitalWrite(layer[i-1], 0);
  250.       delay(x);
  251.     }
  252.   }
  253. }
  254. ////////flicker off
  255. void flickerOff()
  256. {
  257.   turnEverythingOn();
  258.   for(int i = 0; i!= 150; i+=5)
  259.   {
  260.     turnEverythingOff();
  261.     delay(i+50);
  262.     turnEverythingOn();
  263.     delay(i);
  264.   }
  265. }
  266.  
  267. ////////random flicker
  268. void randomflicker()
  269. {
  270.   turnEverythingOff();
  271.   int x = 10;
  272.   for(int i = 0; i !=750; i+=2)
  273.   {
  274.     int randomLayer = random(0,3);
  275.     int randomLed = random(0,9);
  276.  
  277.     digitalWrite(layer[randomLayer], 1);
  278.     digitalWrite(led[randomLed], 0);
  279.     delay(x);
  280.     digitalWrite(layer[randomLayer], 0);
  281.     digitalWrite(led[randomLed], 1);
  282.     delay(x);
  283.   }
  284. }
  285. //////////random rain
  286. void randomRain()
  287. {
  288.   turnEverythingOff();
  289.   int x = 100;
  290.   for(int i = 0; i!=60; i+=2)
  291.   {
  292.     int randomLed = random(0,9);
  293.     digitalWrite(led[randomLed], 0);
  294.     digitalWrite(layer[0], 1);
  295.     delay(x+50);
  296.     digitalWrite(layer[0], 0);
  297.     digitalWrite(layer[1], 1);
  298.     delay(x);
  299.     digitalWrite(layer[1], 0);
  300.     digitalWrite(layer[2], 1);
  301.     delay(x);
  302.     digitalWrite(layer[2], 0);
  303.     digitalWrite(layer[0], 1);
  304.     delay(x+50);
  305.     digitalWrite(layer[0], 0);
  306.     digitalWrite(led[randomLed], 1);
  307.   }
  308. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement