API tools faq
paste
Advertisement
Guest User

Untitled

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