API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 11th, 2019
131
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.52 KB | None | 0 0
raw download clone embed print report
  1. #include "msp.h"
  2. #include "stdbool.h"
  3. #include "stdint.h"
  4. #include "stdio.h"
  5. #include <ti/devices/msp432p4xx/driverlib/driverlib.h>
  6.  
  7.  
  8. /* #DEFINES */
  9.  
  10. #define RGB_MAX 255
  11. #define LED_PORT GPIO_PORT_P2
  12. #define LED_PIN GPIO_PIN3
  13. #define LIGHTS 13
  14. enum State{Stopped, Progressing}; //The various blinking states the strip can be in
  15.  
  16.  
  17. /* Prototype function calls */
  18. void setColor(uint8_t g, uint8_t r, uint8_t b);
  19. void setGRB();
  20. void set_led_white();
  21. void set_led_off();
  22. void setAnimation();
  23. void icicleAnimation();
  24. //void hokieStone();
  25. void mardisGras();
  26. void icicleStill();
  27. void icicle2();
  28. void icicleAnimation2();
  29. void crossEndedAnimation();
  30. void rainbowAnimation();
  31.  
  32.  
  33.  
  34. struct LED {
  35. uint8_t red, green, blue;
  36. };
  37. struct LED led_strip[LIGHTS]; //initialize the struct
  38. uint32_t frame = 0;
  39.  
  40. /**
  41. * main.c
  42. */
  43. void main(void)
  44. {
  45. WDT_A->CTL = WDT_A_CTL_PW | WDT_A_CTL_HOLD; // stop watchdog timer
  46.  
  47. //Initialize ports
  48. MAP_GPIO_setAsOutputPin(LED_PORT, LED_PIN);
  49.  
  50. //struct LED led_strip[LIGHTS]; //initialize the struct
  51. //start the first color as white
  52. set_led_off();
  53. __delay_cycles(4000000);
  54. set_led_white();
  55.  
  56. //set_led_white();
  57. // uint32_t frameRate = BPM/60*20.8*10^9; //20.8 ns for one frame. 1 bpm =
  58. __delay_cycles(200000);
  59. __delay_cycles(4000000);
  60.  
  61. //do all calculations before entering the while loop
  62.  
  63.  
  64. while(1) {
  65. //do the color set here, since frame rate doesn't matter
  66. /* DO ALL THE CALCULATIONS FOR THE COLOR OF THE LIGHTS */
  67. // setGRB();
  68. // __delay_cycles(40000000);
  69. // set_led_white();
  70. // __delay_cycles(40000000);
  71. // set_led_off();
  72. // __delay_cycles(40000000);
  73. // hokieStone();
  74. // mardisGras();
  75. // icicleStill();
  76. // icicle2();
  77. // icicleAnimation2();
  78. // icicleAnimation3();
  79.  
  80. // setGRB();
  81. // mardisGras();
  82. int i;
  83. // for(i=0;i<10;i++){
  84. // icicleAnimation();
  85. // }
  86. /**
  87. for(i =0; i<10; i++) {
  88. crossEndedAnimation();
  89. }
  90. */
  91. rainbowAnimation();
  92.  
  93. // for(i=0; i<10; i++) {
  94. // rainbowAnimation();
  95. // }
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103. //SET EACH OF THE LEDS
  104. int noOps;
  105.  
  106. /* SET ONE FRAME ONE FRAME */
  107.  
  108. // for(i = 0; i < LIGHTS; i++) {
  109. //
  110. // //icicleAnimation();
  111. // setColor(led_strip[i].green, led_strip[i].red, led_strip[i].blue);
  112. // //move to next light in strip
  113. // __delay_cycles(1000);
  114. //
  115. //
  116. // }
  117. //go to next frame
  118. //__delay_cycles(4000000);
  119. /**
  120. for(i = 0; i < frameRate; i++) {
  121. __no_operation();
  122. }
  123. */
  124.  
  125. }
  126. }
  127.  
  128.  
  129.  
  130. /**
  131. * Cycles through to turn on one GRB light
  132. */
  133.  
  134. void setColor(uint8_t g, uint8_t r, uint8_t b) {
  135. //bit shift down
  136. uint32_t color = (g<<16) | (r<<8) | b;
  137. uint8_t i;
  138. uint8_t ar[24];
  139. for(i = 0; i < 8; i++) {
  140. ar[i] = (g >> (7 - i)) & 0b00000001;
  141. }
  142. for(i = 0; i < 8; i++) {
  143. ar[i+8] = (r >> (7 - i)) & 0b00000001;
  144. }
  145. for(i = 0; i < 8; i++) {
  146. ar[i+16] = (b >> (7 - i)) & 0b00000001;
  147. }
  148.  
  149. uint8_t *p = ar;
  150. for(i = 0; i < 24; i++) {
  151. //bit shift, starting from MSB in g, r, then b
  152.  
  153. if(*(p+i)) {
  154. //Turn high on, so 700 ns or 19 no-op calls
  155. P2->OUT |= 0x08;
  156.  
  157. __no_operation();
  158. __no_operation();
  159. __no_operation();
  160. __no_operation();
  161. __no_operation();
  162. __no_operation();
  163. __no_operation();
  164. __no_operation();
  165. __no_operation();
  166. __no_operation();
  167. __no_operation();
  168. __no_operation();
  169. __no_operation();
  170. __no_operation();
  171. __no_operation();
  172. __no_operation();
  173. __no_operation();
  174. __no_operation();
  175. __no_operation();
  176. __no_operation();
  177. __no_operation();
  178. __no_operation();
  179. __no_operation();
  180. __no_operation();
  181. __no_operation();
  182. __no_operation();
  183. __no_operation();
  184.  
  185.  
  186.  
  187.  
  188.  
  189.  
  190. //set off, so 600 ns or 15 no-op calls
  191. P2->OUT &= ~0x08;
  192.  
  193. __no_operation();
  194. __no_operation();
  195. __no_operation();
  196. __no_operation();
  197.  
  198.  
  199.  
  200.  
  201.  
  202. }
  203.  
  204. else {
  205.  
  206. //Set high, so 350 ns or 3 no-op calls
  207. P2->OUT |= 0x08;
  208. __no_operation();
  209. __no_operation();
  210. __no_operation();
  211. __no_operation();
  212. __no_operation();
  213. __no_operation();
  214. __no_operation();
  215. __no_operation();
  216. __no_operation();
  217.  
  218. //running at 48MHz, each NOP causes 20.8 ns delay
  219.  
  220.  
  221. //set off, so 600 ns or 15 no-op calls
  222. P2->OUT &= ~0x08;
  223. __no_operation();
  224. __no_operation();
  225. __no_operation();
  226. __no_operation();
  227. __no_operation();
  228. __no_operation();
  229. __no_operation();
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238. }
  239. // p++;
  240. }
  241.  
  242. //move to next pixel
  243.  
  244. //send high signal
  245. }
  246.  
  247. void set_led_off() {
  248. int i;
  249. for(i = 0; i < LIGHTS; i++)
  250. {
  251. led_strip[i].red = 0;
  252. led_strip[i].blue = 0;
  253. led_strip[i].green = 0;
  254. }
  255.  
  256. for(i = 0; i < LIGHTS; i++)
  257. {
  258. setColor(led_strip[i].green, led_strip[i].red, led_strip[i].blue);
  259. }
  260.  
  261.  
  262.  
  263. }
  264.  
  265. void set_led_white() {
  266. int i;
  267. for(i = 0; i < LIGHTS; i++)
  268. {
  269. led_strip[i].red = RGB_MAX;
  270. led_strip[i].blue = RGB_MAX;
  271. led_strip[i].green = RGB_MAX;
  272. }
  273.  
  274.  
  275. for(i = 0; i < LIGHTS; i++)
  276. {
  277. setColor(led_strip[i].green, led_strip[i].red, led_strip[i].blue);
  278. }
  279.  
  280.  
  281.  
  282. }
  283.  
  284.  
  285. void setGRB() {
  286. int j;
  287. for(j=0; j < LIGHTS; j++) {
  288. /* Set every first light to green */
  289. if(j%3 == 0) {
  290. led_strip[j].green =RGB_MAX;
  291. led_strip[j].red = 0;
  292. led_strip[j].blue = 0;
  293. }
  294.  
  295. /* Set every second light to red*/
  296. if(j%3 == 1) {
  297.  
  298. led_strip[j].green =0;
  299. led_strip[j].red = RGB_MAX;
  300. led_strip[j].blue = 0;
  301. }
  302.  
  303. /* Set every third light to blue*/
  304. if(j%3 == 2) {
  305. led_strip[j].green =0;
  306. led_strip[j].red = 0;
  307. led_strip[j].blue = RGB_MAX;
  308. }
  309. }
  310.  
  311.  
  312. /* Call to set the colors */
  313. int i;
  314. for(i = 0; i < LIGHTS; i++) {
  315. //icicleAnimation();
  316. setColor(led_strip[i].green, led_strip[i].red, led_strip[i].blue);
  317. //move to next light in strip
  318. __delay_cycles(1000);
  319. }
  320. }
  321.  
  322. void mardisGras() {
  323. int j;
  324. for(j=0; j < LIGHTS; j++) {
  325. /* Set every first light to green */
  326. if(j%5 == 0) {
  327. led_strip[j].green =255;
  328. led_strip[j].red = 0;
  329. led_strip[j].blue = 0;
  330. }
  331.  
  332. /* Set every second light to red*/
  333. if(j%5 == 1) {
  334.  
  335. led_strip[j].green =69;
  336. led_strip[j].red = 139;
  337. led_strip[j].blue = 19;
  338. }
  339.  
  340. /* Set every third light to blue*/
  341. if(j%5 == 2) {
  342. led_strip[j].green =0;
  343. led_strip[j].red = 255;
  344. led_strip[j].blue = 255;
  345. }
  346.  
  347. if(j%5 == 3) {
  348. led_strip[j].green =100;
  349. led_strip[j].red = 100;
  350. led_strip[j].blue = 0;
  351. }
  352.  
  353. if(j%5 == 4) {
  354. led_strip[j].green =215;
  355. led_strip[j].red = 255;
  356. led_strip[j].blue = 0;
  357. }
  358. }
  359.  
  360.  
  361. /* Call to set the colors */
  362. int i;
  363. for(i = 0; i < LIGHTS; i++) {
  364. //icicleAnimation();
  365. setColor(led_strip[i].green, led_strip[i].red, led_strip[i].blue);
  366. //move to next light in strip
  367. __delay_cycles(1000);
  368. }
  369. }
  370.  
  371.  
  372.  
  373.  
  374.  
  375. void icicleAnimation() {
  376. //TODO change icicle colors
  377. /* SET COLOR ARRAY */
  378. int j;
  379.  
  380. led_strip[0].green =255;
  381. led_strip[0].red = 0;
  382. led_strip[0].blue = 0;
  383.  
  384. led_strip[1].green =69;
  385. led_strip[1].red = 139;
  386. led_strip[1].blue = 19;
  387.  
  388. led_strip[2].green =0;
  389. led_strip[2].red = 255;
  390. led_strip[2].blue = 255;
  391.  
  392. led_strip[3].green =255;
  393. led_strip[3].red = 203;
  394. led_strip[3].blue = 153;
  395.  
  396. led_strip[4].green =255;
  397. led_strip[4].red = 229;
  398. led_strip[4].blue = 204;
  399.  
  400. for(j=5; j < LIGHTS; j++) {
  401. /* Set every light off */
  402. led_strip[j].green = 0;
  403. led_strip[j].red = 0;
  404. led_strip[j].blue = 0;
  405. }
  406.  
  407. /* NOW RUN FRAMES*/
  408. uint32_t frame = 0;
  409. uint32_t i;
  410.  
  411. while(frame < LIGHTS) {
  412. for(i = 0; i < LIGHTS; i++) {
  413. setColor(led_strip[(LIGHTS-frame+i)%LIGHTS].green, led_strip[(LIGHTS-frame+i)%LIGHTS].red, led_strip[(LIGHTS-frame+i)%LIGHTS].blue);
  414. }
  415. frame++;
  416. __delay_cycles(4000000);
  417. }
  418. }
  419.  
  420. void crossEndedAnimation() {
  421.  
  422. uint8_t b = 0;
  423. uint8_t g0 = 0;
  424. uint8_t g1 = 50;
  425. uint8_t g2 = 100;
  426. uint8_t g3 = 150;
  427. uint8_t g4 = 200;
  428. uint8_t g5 = 255;
  429. uint8_t r0 = 0;
  430. uint8_t r1 = 50;
  431. uint8_t r2 = 100;
  432. uint8_t r3 = 150;
  433. uint8_t r4 = 200;
  434. uint8_t r5 = 255;
  435.  
  436.  
  437.  
  438.  
  439. /* NOW RUN FRAMES*/
  440. uint32_t frame = 0;
  441. uint32_t i;
  442.  
  443. while(frame < LIGHTS) {
  444. /* Change values of array*/
  445. for(i = 0; i < frame; i++) {
  446. led_strip[i].green = g0;
  447. led_strip[i].red = r0;
  448. led_strip[i].blue = b;
  449. led_strip[LIGHTS-i-1].green = g0;
  450. led_strip[LIGHTS-i-1].red = r0;
  451. led_strip[LIGHTS-i-1].blue = b;
  452. }
  453. //Set green gradient
  454. led_strip[i+1].green = g1;
  455. led_strip[i+1].red = r0;
  456. led_strip[i+2].green = g2;
  457. led_strip[i+2].red = r0;
  458. // led_strip[i+3].green = g3;
  459. // led_strip[i+3].red = r0;
  460. // led_strip[i+4].green = g4;
  461. // led_strip[i+4].red = r0;
  462. // led_strip[i+5].green = g5;
  463. // led_strip[i+5].red = r0;
  464.  
  465. //Set the red gradient
  466. led_strip[LIGHTS-i-2].green = g0;
  467. led_strip[LIGHTS-i-2].red = r1;
  468. led_strip[LIGHTS-i-3].green = g0;
  469. led_strip[LIGHTS-i-3].red = r2;
  470. // led_strip[LIGHTS-i-4].green = g0;
  471. // led_strip[LIGHTS-i-4].red = r3;
  472. // led_strip[LIGHTS-i-5].green = g0;
  473. // led_strip[LIGHTS-i-5].red = r4;
  474. // led_strip[LIGHTS-i-6].green = g0;
  475. // led_strip[LIGHTS-i-6].red = r5;
  476.  
  477. /* Display values of array*/
  478. for(i = 0; i < LIGHTS; i++) {
  479. setColor(led_strip[i].green, led_strip[i].red, led_strip[i].blue);
  480. }
  481. frame++;
  482. __delay_cycles(4000000);
  483. }
  484. }
  485.  
  486.  
  487. void rainbowAnimation() {
  488.  
  489. int j;
  490. int i;
  491.  
  492. for(j=0; j < LIGHTS*(3/8); j++){
  493. led_strip[j].green = 128*(16/3)*j/LIGHTS;
  494. led_strip[j].red = 255;
  495. led_strip[j].blue = 0;
  496. }
  497.  
  498. for(j=LIGHTS*(3/8); j < LIGHTS*(4/8); j++){
  499. led_strip[j].green = 255;
  500. led_strip[j].red = 255 - 255*2*j/LIGHTS;
  501. led_strip[j].blue = 0;
  502. }
  503.  
  504. for(j=LIGHTS*(4/8); j < LIGHTS*(5/8); j++){
  505. led_strip[j].green = 255 - 255*(8/5)*j/LIGHTS;
  506. led_strip[j].red = 0;
  507. led_strip[j].blue = 255*(8/5)*j/LIGHTS;
  508. }
  509.  
  510. for(j=LIGHTS*(5/8); j < LIGHTS*(6/8); j++){
  511. led_strip[j].green = 0;
  512. led_strip[j].red = 75*(8/6)*j/LIGHTS;
  513. led_strip[j].blue = 255 - 125*(8/6)*j/LIGHTS;
  514. }
  515.  
  516. for(j=LIGHTS*(6/8); j < LIGHTS*(7/8); j++){
  517. led_strip[j].green = 0;
  518. led_strip[j].red = 75+73*(8/7)*j/LIGHTS;
  519. led_strip[j].blue = 130+81*(8/7)*j/LIGHTS;
  520. }
  521.  
  522. for(j=LIGHTS*(7/8); j < LIGHTS*(8/8); j++){
  523. led_strip[j].green = 0;
  524. led_strip[j].red = 148+107*j/LIGHTS;
  525. led_strip[j].blue = 211-211*j/LIGHTS;
  526. }
  527.  
  528. while(frame < LIGHTS) {
  529. for(i = 0; i < LIGHTS; i++) {
  530. setColor(led_strip[(LIGHTS-frame+i)%LIGHTS].green, led_strip[(LIGHTS-frame+i)%LIGHTS].red, led_strip[(LIGHTS-frame+i)%LIGHTS].blue);
  531. }
  532. frame++;
  533. __delay_cycles(4000000);
  534. }
  535. }
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!