API tools faq
paste
Advertisement
Guest User

Untitled

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