API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 20th, 2018
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.94 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. 4x4x4 LED Cube
  3. Connection Setup:
  4. Columns
  5. [(x,y)-Pin]
  6. (1,1)-13
  7. (1,2)-12
  8. (1,3)-11
  9. (1,4)-10
  10. (2,1)-9
  11. (2,2)-8
  12. (2,3)-7
  13. (2,4)-6
  14. (3,1)-5
  15. (3-2)-4
  16. (3-3)-3
  17. (3,4)-2
  18. (4,1)-1
  19. (4,2)-0
  20. (4,3)-A5
  21. (4,4)-A4
  22. Layers
  23. [layer-Pin]
  24. a-A0
  25. b-A1
  26. c-A2
  27. d-A3
  28. */
  29. //initializing and declaring led rows
  30. int column[4]={13,12,11,10};
  31. //initializing and declaring led layers
  32. int layer[4]={A3,A2,A1,A0};
  33.  
  34. int time = 250;
  35.  
  36. void setup()
  37. {
  38. //setting rows to ouput
  39. for(int i = 0; i<4; i++)
  40. {
  41. pinMode(column[i], OUTPUT);
  42. }
  43. //setting layers to output
  44. for(int i = 0; i<4; i++)
  45. {
  46. pinMode(layer[i], OUTPUT);
  47. }
  48. //seeding random for random pattern
  49. randomSeed(analogRead(10));
  50. }
  51. //xxxxxxxxxxxxxxxxxxxxFUNCTION LOOPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  52. //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  53.  
  54. void loop()
  55. {
  56. turnEverythingOff();//turn all off
  57. flickerOn();
  58. turnEverythingOn();//turn all on
  59. delay(time);
  60. turnOnAndOffAllByLayerUpAndDownNotTimed();
  61. layerstompUpAndDown();
  62. turnOnAndOffAllByColumnSideways();
  63. delay(time);
  64. aroundEdgeDown();
  65. turnEverythingOff();
  66. randomflicker();
  67. randomRain();
  68. diagonalRectangle();
  69. goThroughAllLedsOneAtATime();
  70. propeller();
  71. spiralInAndOut();
  72. flickerOff();
  73. turnEverythingOff();
  74. delay(2000);
  75. }
  76.  
  77.  
  78. //xxxxxxxxxxxxxxxxxxxxFUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  79. //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  80.  
  81. ///////////////////////////////////////////////////////////turn all off
  82. void turnEverythingOff()
  83. {
  84. for(int i = 0; i<4; i++)
  85. {
  86. digitalWrite(column[i], 1);
  87. }
  88. for(int i = 0; i<4; i++)
  89. {
  90. digitalWrite(layer[i], 0);
  91. }
  92. }
  93.  
  94. ////////////////////////////////////////////////////////////turn all on
  95. void turnEverythingOn()
  96. {
  97. for(int i = 0; i<4; i++)
  98. {
  99. digitalWrite(column[i], 0);
  100. }
  101. //turning on layers
  102. for(int i = 0; i<4; i++)
  103. {
  104. digitalWrite(layer[i], 1);
  105. }
  106. }
  107. ///////////////////////////////////////////////////////turn columns off
  108. void turnColumnsOff()
  109. {
  110. for(int i = 0; i<4; i++)
  111. {
  112. digitalWrite(column[i], 1);
  113. }
  114. }
  115. /////////////////////////////////////////////////////////////flicker on
  116. void flickerOn()
  117. {
  118. int i = 150;
  119. while(i != 0)
  120. {
  121. turnEverythingOn();
  122. delay(i);
  123. turnEverythingOff();
  124. delay(i);
  125. i-= 5;
  126. }
  127. }
  128. //////////////turn everything on and off by layer up and down NOT TIMED
  129. void turnOnAndOffAllByLayerUpAndDownNotTimed()
  130. {
  131. int x = 75;
  132. for(int i = 5; i != 0; i--)
  133. {
  134. turnEverythingOn();
  135. for(int i = 4; i!=0; i--)
  136. {
  137. digitalWrite(layer[i-1], 0);
  138. delay(x);
  139. }
  140. for(int i = 0; i<4; i++)
  141. {
  142. digitalWrite(layer[i], 1);
  143. delay(x);
  144. }
  145. for(int i = 0; i<4; i++)
  146. {
  147. digitalWrite(layer[i], 0);
  148. delay(x);
  149. }
  150. for(int i = 4; i!=0; i--)
  151. {
  152. digitalWrite(layer[i-1], 1);
  153. delay(x);
  154. }
  155. }
  156. }
  157. //////////////////////////turn everything on and off by column sideways
  158. void turnOnAndOffAllByColumnSideways()
  159. {
  160. int x = 75;
  161. turnEverythingOff();
  162. //turn on layers
  163. for(int i = 0; i<4; i++)
  164. {
  165. digitalWrite(layer[i], 1);
  166. }
  167. for(int y = 0; y<3; y++)
  168. {
  169. //turn on 0-3
  170. for(int i = 0; i<4; i++)
  171. {
  172. digitalWrite(column[i], 0);
  173. delay(x);
  174. }
  175. //turn on 4-7
  176. for(int i = 4; i<8; i++)
  177. {
  178. digitalWrite(column[i], 0);
  179. delay(x);
  180. }
  181. //turn on 8-11
  182. for(int i = 8; i<12; i++)
  183. {
  184. digitalWrite(column[i], 0);
  185. delay(x);
  186. }
  187. //turn on 12-15
  188. for(int i = 12; i<4; i++)
  189. {
  190. digitalWrite(column[i], 0);
  191. delay(x);
  192. }
  193. //turn off 0-3
  194. for(int i = 0; i<4; i++)
  195. {
  196. digitalWrite(column[i], 1);
  197. delay(x);
  198. }
  199. //turn off 4-7
  200. for(int i = 4; i<8; i++)
  201. {
  202. digitalWrite(column[i], 1);
  203. delay(x);
  204. }
  205. //turn off 8-11
  206. for(int i = 8; i<12; i++)
  207. {
  208. digitalWrite(column[i], 1);
  209. delay(x);
  210. }
  211. //turn off 12-15
  212. for(int i = 12; i<4; i++)
  213. {
  214. digitalWrite(column[i], 1);
  215. delay(x);
  216. }
  217. //turn on 12-15
  218. for(int i = 12; i<4; i++)
  219. {
  220. digitalWrite(column[i], 0);
  221. delay(x);
  222. }
  223. //turn on 8-11
  224. for(int i = 8; i<12; i++)
  225. {
  226. digitalWrite(column[i], 0);
  227. delay(x);
  228. }
  229. //turn on 4-7
  230. for(int i = 4; i<8; i++)
  231. {
  232. digitalWrite(column[i], 0);
  233. delay(x);
  234. }
  235. //turn on 0-3
  236. for(int i = 0; i<4; i++)
  237. {
  238. digitalWrite(column[i], 0);
  239. delay(x);
  240. }
  241. //turn off 12-15
  242. for(int i = 12; i<4; i++)
  243. {
  244. digitalWrite(column[i], 1);
  245. delay(x);
  246. }
  247. //turn off 8-11
  248. for(int i = 8; i<12; i++)
  249. {
  250. digitalWrite(column[i], 1);
  251. delay(x);
  252. }
  253. //turn off 4-7
  254. for(int i = 4; i<8; i++)
  255. {
  256. digitalWrite(column[i], 1);
  257. delay(x);
  258. }
  259. //turn off 0-3
  260. for(int i = 0; i<4; i++)
  261. {
  262. digitalWrite(column[i], 1);
  263. delay(x);
  264. }
  265. }
  266. }
  267. /////////////////////////////////////////up and down single layer stomp
  268. void layerstompUpAndDown()
  269. {
  270. int x = 75;
  271. for(int i = 0; i<4; i++)
  272. {
  273. digitalWrite(layer[i], 0);
  274. }
  275. for(int y = 0; y<5; y++)
  276. {
  277. for(int count = 0; count<1; count++)
  278. {
  279. for(int i = 0; i<4; i++)
  280. {
  281. digitalWrite(layer[i], 1);
  282. delay(x);
  283. digitalWrite(layer[i], 0);
  284. }
  285. for(int i = 4; i !=0; i--)
  286. {
  287. digitalWrite(layer[i-1], 1);
  288. delay(x);
  289. digitalWrite(layer[i-1], 0);
  290. }
  291. }
  292. for(int i = 0; i<4; i++)
  293. {
  294. digitalWrite(layer[i], 1);
  295. delay(x);
  296. }
  297. for(int i = 4; i!=0; i--)
  298. {
  299. digitalWrite(layer[i-1], 0);
  300. delay(x);
  301. }
  302. }
  303. }
  304. ////////////////////////////////////////////////////////////flicker off
  305. void flickerOff()
  306. {
  307. turnEverythingOn();
  308. for(int i = 0; i!= 150; i+=5)
  309. {
  310. turnEverythingOff();
  311. delay(i+50);
  312. turnEverythingOn();
  313. delay(i);
  314. }
  315. }
  316. ///////////////////////////////////////////around edge of the cube down
  317. void aroundEdgeDown()
  318. {
  319. for(int x = 200; x != 0; x -=50)
  320. {
  321. turnEverythingOff();
  322. for(int i = 4; i != 0; i--)
  323. {
  324. digitalWrite(layer[i-1], 1);
  325. digitalWrite(column[5], 0);
  326. digitalWrite(column[6], 0);
  327. digitalWrite(column[9], 0);
  328. digitalWrite(column[10], 0);
  329.  
  330. digitalWrite(column[0], 0);
  331. delay(x);
  332. digitalWrite(column[0], 1);
  333. digitalWrite(column[4], 0);
  334. delay(x);
  335. digitalWrite(column[4], 1);
  336. digitalWrite(column[8], 0);
  337. delay(x);
  338. digitalWrite(column[8], 1);
  339. digitalWrite(column[12], 0);
  340. delay(x);
  341. digitalWrite(column[12], 1);
  342. digitalWrite(column[13], 0);
  343. delay(x);
  344. digitalWrite(column[13], 1);
  345. digitalWrite(column[15], 0);
  346. delay(x);
  347. digitalWrite(column[15], 1);
  348. digitalWrite(column[14], 0);
  349. delay(x);
  350. digitalWrite(column[14], 1);
  351. digitalWrite(column[11], 0);
  352. delay(x);
  353. digitalWrite(column[11], 1);
  354. digitalWrite(column[7], 0);
  355. delay(x);
  356. digitalWrite(column[7], 1);
  357. digitalWrite(column[3], 0);
  358. delay(x);
  359. digitalWrite(column[3], 1);
  360. digitalWrite(column[2], 0);
  361. delay(x);
  362. digitalWrite(column[2], 1);
  363. digitalWrite(column[1], 0);
  364. delay(x);
  365. digitalWrite(column[1], 1);
  366. }
  367. }
  368. }
  369. /////////////////////////////////////////////////////////random flicker
  370. void randomflicker()
  371. {
  372. turnEverythingOff();
  373. int x = 10;
  374. for(int i = 0; i !=750; i+=2)
  375. {
  376. int randomLayer = random(0,4);
  377. int randomColumn = random(0,4);
  378.  
  379. digitalWrite(layer[randomLayer], 1);
  380. digitalWrite(column[randomColumn], 0);
  381. delay(x);
  382. digitalWrite(layer[randomLayer], 0);
  383. digitalWrite(column[randomColumn], 1);
  384. delay(x);
  385. }
  386. }
  387. ////////////////////////////////////////////////////////////random rain
  388. void randomRain()
  389. {
  390. turnEverythingOff();
  391. int x = 100;
  392. for(int i = 0; i!=60; i+=2)
  393. {
  394. int randomColumn = random(0,4);
  395. digitalWrite(column[randomColumn], 0);
  396. digitalWrite(layer[0], 1);
  397. delay(x+50);
  398. digitalWrite(layer[0], 0);
  399. digitalWrite(layer[1], 1);
  400. delay(x);
  401. digitalWrite(layer[1], 0);
  402. digitalWrite(layer[2], 1);
  403. delay(x);
  404. digitalWrite(layer[2], 0);
  405. digitalWrite(layer[3], 1);
  406. delay(x+50);
  407. digitalWrite(layer[3], 0);
  408. digitalWrite(column[randomColumn], 1);
  409. }
  410. }
  411. /////////////////////////////////////////////////////diagonal rectangle
  412. void diagonalRectangle()
  413. {
  414. int x = 350;
  415. turnEverythingOff();
  416. for(int count = 0; count<5; count++)
  417. {
  418. //top left
  419. for(int i = 0; i<8; i++)
  420. {
  421. digitalWrite(column[i], 0);
  422. }
  423. digitalWrite(layer[3], 1);
  424. digitalWrite(layer[2], 1);
  425. delay(x);
  426. turnEverythingOff();
  427. //middle middle
  428. for(int i = 4; i<12; i++)
  429. {
  430. digitalWrite(column[i], 0);
  431. }
  432. digitalWrite(layer[1], 1);
  433. digitalWrite(layer[2], 1);
  434. delay(x);
  435. turnEverythingOff();
  436. //bottom right
  437. for(int i = 8; i<4; i++)
  438. {
  439. digitalWrite(column[i], 0);
  440. }
  441. digitalWrite(layer[0], 1);
  442. digitalWrite(layer[1], 1);
  443. delay(x);
  444. turnEverythingOff();
  445. //bottom middle
  446. for(int i = 4; i<12; i++)
  447. {
  448. digitalWrite(column[i], 0);
  449. }
  450. digitalWrite(layer[0], 1);
  451. digitalWrite(layer[1], 1);
  452. delay(x);
  453. turnEverythingOff();
  454. //bottom left
  455. for(int i = 0; i<8; i++)
  456. {
  457. digitalWrite(column[i], 0);
  458. }
  459. digitalWrite(layer[0], 1);
  460. digitalWrite(layer[1], 1);
  461. delay(x);
  462. turnEverythingOff();
  463. //middle middle
  464. for(int i = 4; i<12; i++)
  465. {
  466. digitalWrite(column[i], 0);
  467. }
  468. digitalWrite(layer[1], 1);
  469. digitalWrite(layer[2], 1);
  470. delay(x);
  471. turnEverythingOff();
  472. //top right
  473. for(int i = 8; i<4; i++)
  474. {
  475. digitalWrite(column[i], 0);
  476. }
  477. digitalWrite(layer[2], 1);
  478. digitalWrite(layer[3], 1);
  479. delay(x);
  480. turnEverythingOff();
  481. //top middle
  482. for(int i = 4; i<12; i++)
  483. {
  484. digitalWrite(column[i], 0);
  485. }
  486. digitalWrite(layer[2], 1);
  487. digitalWrite(layer[3], 1);
  488. delay(x);
  489. turnEverythingOff();
  490. }
  491. //top left
  492. for(int i = 0; i<8; i++)
  493. {
  494. digitalWrite(column[i], 0);
  495. }
  496. digitalWrite(layer[3], 1);
  497. digitalWrite(layer[2], 1);
  498. delay(x);
  499. turnEverythingOff();
  500. }
  501. //////////////////////////////////////////////////////////////propeller
  502. void propeller()
  503. {
  504. turnEverythingOff();
  505. int x = 90;
  506. for(int y = 4; y>0; y--)
  507. {
  508. for(int i = 0; i<6; i++)
  509. {
  510. //turn on layer
  511. digitalWrite(layer[y-1], 1);
  512. //a1
  513. turnColumnsOff();
  514. digitalWrite(column[0], 0);
  515. digitalWrite(column[5], 0);
  516. digitalWrite(column[10], 0);
  517. digitalWrite(column[15], 0);
  518. delay(x);
  519. //b1
  520. turnColumnsOff();
  521. digitalWrite(column[4], 0);
  522. digitalWrite(column[5], 0);
  523. digitalWrite(column[10], 0);
  524. digitalWrite(column[11], 0);
  525. delay(x);
  526. //c1
  527. turnColumnsOff();
  528. digitalWrite(column[6], 0);
  529. digitalWrite(column[7], 0);
  530. digitalWrite(column[8], 0);
  531. digitalWrite(column[9], 0);
  532. delay(x);
  533. //d1
  534. turnColumnsOff();
  535. digitalWrite(column[3], 0);
  536. digitalWrite(column[6], 0);
  537. digitalWrite(column[9], 0);
  538. digitalWrite(column[12], 0);
  539. delay(x);
  540. //d2
  541. turnColumnsOff();
  542. digitalWrite(column[2], 0);
  543. digitalWrite(column[6], 0);
  544. digitalWrite(column[9], 0);
  545. digitalWrite(column[13], 0);
  546. delay(x);
  547. //d3
  548. turnColumnsOff();
  549. digitalWrite(column[1], 0);
  550. digitalWrite(column[5], 0);
  551. digitalWrite(column[10], 0);
  552. digitalWrite(column[14], 0);
  553. delay(x);
  554. }
  555. }
  556. //d4
  557. turnColumnsOff();
  558. digitalWrite(column[0], 0);
  559. digitalWrite(column[5], 0);
  560. digitalWrite(column[10], 0);
  561. digitalWrite(column[15], 0);
  562. delay(x);
  563. }
  564. //////////////////////////////////////////////////////spiral in and out
  565. void spiralInAndOut()
  566. {
  567. turnEverythingOn();
  568. int x = 60;
  569. for(int i = 0; i<6; i++)
  570. {
  571. //spiral in clockwise
  572. digitalWrite(column[0], 1);
  573. delay(x);
  574. digitalWrite(column[1], 1);
  575. delay(x);
  576. digitalWrite(column[2], 1);
  577. delay(x);
  578. digitalWrite(column[3], 1);
  579. delay(x);
  580. digitalWrite(column[7], 1);
  581. delay(x);
  582. digitalWrite(column[11], 1);
  583. delay(x);
  584. digitalWrite(column[15], 1);
  585. delay(x);
  586. digitalWrite(column[14], 1);
  587. delay(x);
  588. digitalWrite(column[13], 1);
  589. delay(x);
  590. digitalWrite(column[12], 1);
  591. delay(x);
  592. digitalWrite(column[8], 1);
  593. delay(x);
  594. digitalWrite(column[4], 1);
  595. delay(x);
  596. digitalWrite(column[5], 1);
  597. delay(x);
  598. digitalWrite(column[6], 1);
  599. delay(x);
  600. digitalWrite(column[10], 1);
  601. delay(x);
  602. digitalWrite(column[9], 1);
  603. delay(x);
  604. ///////////////////////////////////////spiral out counter clockwise
  605. digitalWrite(column[9], 0);
  606. delay(x);
  607. digitalWrite(column[10], 0);
  608. delay(x);
  609. digitalWrite(column[6], 0);
  610. delay(x);
  611. digitalWrite(column[5], 0);
  612. delay(x);
  613. digitalWrite(column[4], 0);
  614. delay(x);
  615. digitalWrite(column[8], 0);
  616. delay(x);
  617. digitalWrite(column[12], 0);
  618. delay(x);
  619. digitalWrite(column[13], 0);
  620. delay(x);
  621. digitalWrite(column[14], 0);
  622. delay(x);
  623. digitalWrite(column[15], 0);
  624. delay(x);
  625. digitalWrite(column[11], 0);
  626. delay(x);
  627. digitalWrite(column[7], 0);
  628. delay(x);
  629. digitalWrite(column[3], 0);
  630. delay(x);
  631. digitalWrite(column[2], 0);
  632. delay(x);
  633. digitalWrite(column[1], 0);
  634. delay(x);
  635. digitalWrite(column[0], 0);
  636. delay(x);
  637. ///////////////////////////////////////spiral in counter clock wise
  638. digitalWrite(column[0], 1);
  639. delay(x);
  640. digitalWrite(column[4], 1);
  641. delay(x);
  642. digitalWrite(column[8], 1);
  643. delay(x);
  644. digitalWrite(column[12], 1);
  645. delay(x);
  646. digitalWrite(column[13], 1);
  647. delay(x);
  648. digitalWrite(column[14], 1);
  649. delay(x);
  650. digitalWrite(column[15], 1);
  651. delay(x);
  652. digitalWrite(column[11], 1);
  653. delay(x);
  654. digitalWrite(column[7], 1);
  655. delay(x);
  656. digitalWrite(column[3], 1);
  657. delay(x);
  658. digitalWrite(column[2], 1);
  659. delay(x);
  660. digitalWrite(column[1], 1);
  661. delay(x);
  662. digitalWrite(column[5], 1);
  663. delay(x);
  664. digitalWrite(column[9], 1);
  665. delay(x);
  666. digitalWrite(column[10], 1);
  667. delay(x);
  668. digitalWrite(column[6], 1);
  669. delay(x);
  670. //////////////////////////////////////////////spiral out clock wise
  671. digitalWrite(column[6], 0);
  672. delay(x);
  673. digitalWrite(column[10], 0);
  674. delay(x);
  675. digitalWrite(column[9], 0);
  676. delay(x);
  677. digitalWrite(column[5], 0);
  678. delay(x);
  679. digitalWrite(column[1], 0);
  680. delay(x);
  681. digitalWrite(column[2], 0);
  682. delay(x);
  683. digitalWrite(column[3], 0);
  684. delay(x);
  685. digitalWrite(column[7], 0);
  686. delay(x);
  687. digitalWrite(column[11], 0);
  688. delay(x);
  689. digitalWrite(column[15], 0);
  690. delay(x);
  691. digitalWrite(column[14], 0);
  692. delay(x);
  693. digitalWrite(column[13], 0);
  694. delay(x);
  695. digitalWrite(column[12], 0);
  696. delay(x);
  697. digitalWrite(column[8], 0);
  698. delay(x);
  699. digitalWrite(column[4], 0);
  700. delay(x);
  701. digitalWrite(column[0], 0);
  702. delay(x);
  703. }
  704. }
  705. //////////////////////////////////////go through all leds one at a time
  706. void goThroughAllLedsOneAtATime()
  707. {
  708. int x = 15;
  709. turnEverythingOff();
  710. for(int y = 0; y<5; y++)
  711. {
  712. //0-3
  713. for(int count = 4; count != 0; count--)
  714. {
  715. digitalWrite(layer[count-1], 1);
  716. for(int i = 0; i<4; i++)
  717. {
  718. digitalWrite(column[i], 0);
  719. delay(x);
  720. digitalWrite(column[i], 1);
  721. delay(x);
  722. }
  723. digitalWrite(layer[count-1], 0);
  724. }
  725. //4-7
  726. for(int count = 0; count < 4; count++)
  727. {
  728. digitalWrite(layer[count], 1);
  729. for(int i = 4; i<8; i++)
  730. {
  731. digitalWrite(column[i], 0);
  732. delay(x);
  733. digitalWrite(column[i], 1);
  734. delay(x);
  735. }
  736. digitalWrite(layer[count], 0);
  737. }
  738. //8-11
  739. for(int count = 4; count != 0; count--)
  740. {
  741. digitalWrite(layer[count-1], 1);
  742. for(int i = 8; i<12; i++)
  743. {
  744. digitalWrite(column[i], 0);
  745. delay(x);
  746. digitalWrite(column[i], 1);
  747. delay(x);
  748. }
  749. digitalWrite(layer[count-1], 0);
  750. }
  751. //12-15
  752. for(int count = 0; count < 4; count++)
  753. {
  754. digitalWrite(layer[count], 1);
  755. for(int i = 12; i<4; i++)
  756. {
  757. digitalWrite(column[i], 0);
  758. delay(x);
  759. digitalWrite(column[i], 1);
  760. delay(x);
  761. }
  762. digitalWrite(layer[count], 0);
  763. }
  764. }
  765. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!