API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 10th, 2016
64
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.52 KB | None | 0 0
raw download clone embed print report
  1. #include <SPI.h>
  2. #include <SoftwareSerial.h>
  3. SoftwareSerial DebugSerial(2, 3); // RX, TX
  4. #define BLYNK_PRINT DebugSerial
  5. #include <BlynkSimpleStream.h>
  6. #define BLYNK_PRINT
  7. #define BLYNK_PRINT Serial
  8. #include <FastLED.h>
  9.  
  10. #define BLYNK_MSG_LIMIT 200
  11. #define DATA_PIN 6
  12.  
  13. char auth[] = "ea8d214b9f2148d78a3e6152ba9d80a8";
  14. #define NUM_LEDS 40
  15. int HardwareZone = 3;
  16.  
  17. int varHue;
  18. int varHuePrev;
  19. int varHueNew;
  20. int varSaturation;
  21. int varBrightness;
  22. int varManualMode;
  23. int varNextColour;
  24. int varNextColourPrev;
  25. int varBlendingMode;
  26. int varUpdatesPerSec;
  27. int varAlertMode;
  28. int varZone;
  29.  
  30. CRGB leds[NUM_LEDS];
  31.  
  32. //////////////////////////////////////////////////////////////////////////////////////////
  33. void setup()
  34. {
  35. varHue = 190; // Start on a Blue Hue
  36. varSaturation = 255; // Start Full Colour
  37. varBrightness = 255; // Start Full Brightness
  38. varManualMode = 0; // Start in preset mode
  39. varNextColour = 0; //
  40. varNextColourPrev = 0; // Set Button State
  41. varBlendingMode = 1; // Start LINEARBLEND
  42. varUpdatesPerSec = 100; // Start on 100 fps
  43. varAlertMode = 0; // Start Alert Mode OFF
  44. varZone = 1;
  45. /******** FASTLED ************/
  46. FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  47. DebugSerial.begin(9600);
  48. Serial.begin(9600);
  49. Blynk.begin(Serial, auth);
  50. }
  51.  
  52. /****************************************************************************/
  53. // List of patterns to cycle through. Each is defined as a separate function below.
  54. typedef void (*SimplePatternList[])();
  55. SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, whitescan };
  56. uint8_t gCurrentPatternNumber = 0; // Index number of which pattern is current
  57. uint8_t gHue = 0; // rotating "base color" used by many of the patterns
  58. /****************************************************************************/
  59.  
  60. BLYNK_WRITE(V0) {
  61. if ( (varZone == HardwareZone) || (varZone == 1)) {
  62. varHue = param.asInt();
  63. //terminal.print(nickname);
  64. //terminal.print(" | Hue: ");
  65. //terminal.println(varHue);
  66. //terminal.flush();
  67. //HexRGB = ((long)leds[0].r << 16) | ((long)leds[0].g << 8 ) | (long)leds[0].b;
  68. //Blynk.setProperty(V0, "color", "#" + String(HexRGB, HEX));
  69. }
  70. }
  71. BLYNK_WRITE(V1) {
  72. if ( (varZone == HardwareZone) || (varZone == 1)) {
  73. varSaturation = param.asInt();
  74. //terminal.print(nickname);
  75. //terminal.print(" | Saturation: ");
  76. //terminal.println(varSaturation);
  77. //terminal.flush();
  78. }
  79. }
  80. BLYNK_WRITE(V2) {
  81. if ( (varZone == HardwareZone) || (varZone == 1)) {
  82. varBrightness = param.asInt();
  83. //terminal.print(nickname);
  84. //terminal.print(" | Brightness: ");
  85. //terminal.println(varBrightness);
  86. //terminal.flush();
  87. }
  88. }
  89. BLYNK_WRITE(V3) {
  90. if ( (varZone == HardwareZone) || (varZone == 1)) {
  91. varNextColour = param.asInt();
  92. if (varNextColour == 1 && varNextColourPrev == 0) {
  93. nextPattern();
  94. //terminal.print(nickname);
  95. //terminal.println(" | Next Colour Pattern");
  96. //terminal.flush();
  97. delay(10);
  98. }
  99. varNextColourPrev = varNextColour;
  100. }
  101. }
  102. BLYNK_WRITE(V4) {
  103. if ( (varZone == HardwareZone) || (varZone == 1)) {
  104. varManualMode = 1;
  105. Blynk.virtualWrite(V10, varManualMode);
  106. varBrightness = (int)255;
  107. Blynk.virtualWrite(V2, 255);
  108. varSaturation = (int)255;
  109. Blynk.virtualWrite(V1, 255);
  110. varHue = (int)152;
  111. Blynk.virtualWrite(V0, 152);
  112. //terminal.print(nickname);
  113. //terminal.println(" | Blue");
  114. //terminal.flush();
  115. delay(10);
  116. }
  117. }
  118. BLYNK_WRITE(V5) {
  119. if ( (varZone == HardwareZone) || (varZone == 1)) {
  120. varUpdatesPerSec = param.asInt();
  121. //terminal.print(nickname);
  122. //terminal.print(" | Updates Per Sec: ");
  123. //terminal.println(varUpdatesPerSec);
  124. //terminal.flush();
  125. }
  126. }
  127. BLYNK_WRITE(V6) {
  128. if ( (varZone == HardwareZone) || (varZone == 1)) {
  129. varManualMode = 1;
  130. Blynk.virtualWrite(V10, varManualMode);
  131. varBrightness = (int)255;
  132. Blynk.virtualWrite(V2, 255);
  133. varSaturation = (int)255;
  134. Blynk.virtualWrite(V1, 255);
  135. varHue = (int)0;
  136. Blynk.virtualWrite(V0, 0);
  137. //terminal.print(nickname);
  138. //terminal.println(" | Red");
  139. //terminal.flush();
  140. delay(10);
  141. }
  142. }
  143. BLYNK_WRITE(V7) {
  144. if ( (varZone == HardwareZone) || (varZone == 1)) {
  145. varManualMode = 1;
  146. Blynk.virtualWrite(V10, varManualMode);
  147. varBrightness = (int)255;
  148. Blynk.virtualWrite(V2, 255);
  149. varSaturation = (int)255;
  150. Blynk.virtualWrite(V1, 255);
  151. varHue = (int)80;
  152. Blynk.virtualWrite(V0, 80);
  153. //terminal.print(nickname);
  154. //terminal.println(" | Green");
  155. //terminal.flush();
  156. delay(10);
  157. }
  158. }
  159. BLYNK_WRITE(V8) {
  160. if ( (varZone == HardwareZone) || (varZone == 1)) {
  161. varManualMode = 1;
  162. Blynk.virtualWrite(V10, varManualMode);
  163. varBrightness = (int)255;
  164. Blynk.virtualWrite(V2, 255);
  165. varSaturation = (int)0;
  166. Blynk.virtualWrite(V1, 0);
  167. //terminal.print(nickname);
  168. //terminal.println(" | White");
  169. //terminal.flush();
  170. delay(10);
  171. }
  172. }
  173. BLYNK_WRITE(V10) {
  174. if ( (varZone == HardwareZone) || (varZone == 1)) {
  175. varManualMode = param.asInt();
  176. //terminal.print(nickname);
  177. //terminal.print(" | Manual Mode: ");
  178. if (varManualMode == 0) {
  179. //terminal.println("OFF");
  180. }
  181. if (varManualMode == 1) {
  182. //terminal.println("ON");
  183. }
  184. //terminal.flush();
  185. }
  186. }
  187.  
  188. BLYNK_WRITE(V11) {
  189. gHue = 0;
  190. }
  191.  
  192. BLYNK_WRITE(V15) {
  193. if ( (varZone == HardwareZone) || (varZone == 1)) {
  194. varManualMode = 1;
  195. Blynk.virtualWrite(V10, varManualMode);
  196. varBrightness = (int)255;
  197. Blynk.virtualWrite(V2, 255);
  198. varSaturation = (int)255;
  199. Blynk.virtualWrite(V1, 255);
  200. varHue = (int)27;
  201. Blynk.virtualWrite(V0, 27);
  202. //terminal.print(nickname);
  203. //terminal.println(" | Orange");
  204. //terminal.flush();
  205. delay(10);
  206. }
  207. }
  208.  
  209. BLYNK_WRITE(V12) {
  210. if ( (varZone == HardwareZone) || (varZone == 1)) {
  211. varManualMode = 1;
  212. Blynk.virtualWrite(V10, varManualMode);
  213. varBrightness = (int)255;
  214. Blynk.virtualWrite(V2, 255);
  215. varSaturation = (int)255;
  216. Blynk.virtualWrite(V1, 255);
  217. varHue = (int)64;
  218. Blynk.virtualWrite(V0, 64);
  219. //terminal.print(nickname);
  220. //terminal.println(" | Yellow");
  221. //terminal.flush();
  222. delay(10);
  223. }
  224. }
  225.  
  226. BLYNK_WRITE(V13) {
  227. varAlertMode = param.asInt();
  228. }
  229.  
  230. BLYNK_WRITE(V14) {
  231. if ( (varZone == HardwareZone) || (varZone == 1)) {
  232. varManualMode = 1;
  233. Blynk.virtualWrite(V10, varManualMode);
  234. varBrightness = (int)0;
  235. Blynk.virtualWrite(V2, 0);
  236. //terminal.print(nickname);
  237. //terminal.println(" | OFF");
  238. //terminal.flush();
  239. delay(10);
  240. }
  241. }
  242.  
  243. BLYNK_WRITE(V23) {
  244. varZone = param.asInt();
  245. if (varZone == HardwareZone) {
  246. Blynk.virtualWrite(V0, varHue);
  247. Blynk.virtualWrite(V1, varSaturation);
  248. Blynk.virtualWrite(V2, varBrightness);
  249. Blynk.virtualWrite(V5, varUpdatesPerSec);
  250. Blynk.virtualWrite(V10, varManualMode);
  251. }
  252. }
  253. /****************************************************************************/
  254. void loop()
  255. {
  256. Blynk.run();
  257. if (varAlertMode == 1) {
  258. for (int i = 0; i < 20; i++) {
  259. fill_solid(leds, NUM_LEDS, CRGB::White);
  260. FastLED.show();
  261. FastLED.delay(50);
  262. fill_solid(leds, NUM_LEDS, CRGB::Black);
  263. FastLED.show();
  264. FastLED.delay(50);
  265. }
  266. varAlertMode = 0;
  267. }
  268.  
  269. if (varManualMode == 1) { // Manual Control
  270. fill_solid(leds, NUM_LEDS, CHSV(varHue, varSaturation, varBrightness));
  271. }
  272.  
  273. if (varManualMode == 0) { // Pallette Mode
  274.  
  275. // Call the current pattern function once, updating the 'leds' array
  276. gPatterns[gCurrentPatternNumber]();
  277.  
  278. FastLED.show();
  279. FastLED.delay(1000 / varUpdatesPerSec);
  280.  
  281. EVERY_N_MILLISECONDS( 20 ) {
  282. gHue++; // slowly cycle the "base color" through the rainbow
  283. }
  284. }
  285. FastLED.show();
  286. }
  287. /****************************************************************************/
  288. #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
  289.  
  290. void nextPattern() {
  291. // add one to the current pattern number, and wrap around at the end
  292. gCurrentPatternNumber = (gCurrentPatternNumber + 1) % ARRAY_SIZE( gPatterns);
  293. }
  294.  
  295. void rainbow() {
  296. // FastLED's built-in rainbow generator
  297. fill_rainbow( leds, NUM_LEDS, gHue, 7);
  298. }
  299.  
  300. void rainbowWithGlitter() {
  301. // built-in FastLED rainbow, plus some random sparkly glitter
  302. rainbow();
  303. addGlitter(80);
  304. }
  305.  
  306. void addGlitter( fract8 chanceOfGlitter) {
  307. if ( random8() < chanceOfGlitter) {
  308. leds[ random16(NUM_LEDS) ] += CRGB::White;
  309. }
  310. }
  311.  
  312. void confetti() {
  313. // random colored speckles that blink in and fade smoothly
  314. fadeToBlackBy( leds, NUM_LEDS, 10);
  315. int pos = random16(NUM_LEDS);
  316. leds[pos] += CHSV( gHue + random8(64), 200, 255);
  317. }
  318.  
  319. void sinelon() {
  320. // a colored dot sweeping back and forth, with fading trails
  321. fadeToBlackBy( leds, NUM_LEDS, 20);
  322. int pos = beatsin16(13, 0, NUM_LEDS);
  323. leds[pos] += CHSV( gHue, 255, 192);
  324. }
  325.  
  326. void juggle() {
  327. // eight colored dots, weaving in and out of sync with each other
  328. fadeToBlackBy( leds, NUM_LEDS, 20);
  329. byte dothue = 0;
  330. for ( int i = 0; i < 8; i++) {
  331. leds[beatsin16(i + 7, 0, NUM_LEDS)] |= CHSV(dothue, 200, 255);
  332. dothue += 32;
  333. }
  334. }
  335.  
  336. void whitescan() {
  337. for (int i = 0; i < NUM_LEDS; i++) {
  338. leds[i] = CRGB::White;
  339. FastLED.show();
  340. FastLED.delay(1000 / varUpdatesPerSec);
  341. leds[i] = CRGB::Black;
  342.  
  343. }
  344. }
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!