lukacjusz

LedStripRemote

Oct 12th, 2017
145
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <IRremote.h>
  2. byte pinIr = 11;
  3. IRrecv irrecv(pinIr);
  4. decode_results signals;
  5.  
  6. #include <NewTone.h>
  7. byte pinBuz = 2;
  8.  
  9. int fotoR = 0;
  10. boolean toggleF = 0;
  11.  
  12. //  kody pilota
  13. #define UP 16187647
  14. #define DOWN 16220287
  15. #define ON 16203967
  16. #define OFF 16236607
  17. //#define OFFHOLD 4294967295
  18.  
  19. #define RED 16195807
  20. #define GREEN 16228447
  21. #define BLUE 16212127
  22. #define WHITE 16244767
  23.  
  24. #define ORANGE 16191727
  25. #define YELLOW 16224367
  26. #define CYAN 16208047
  27. #define PURPLE 16240687
  28.  
  29. #define JUMP3 16199887
  30. #define JUMP7 16232527
  31. #define FADE3 16216207
  32. #define FADE7 16248847
  33.  
  34. #define M1 16189687
  35. #define M2 16222327
  36. #define M3 16206007
  37. #define M4 16238647
  38.  
  39. //  piny RGBW
  40. byte  pinR = 5;
  41. byte  pinG = 6;
  42. byte  pinB = 9;
  43. byte  pinW = 10 ;
  44.  
  45. //  jasność diód (pwm 0-255)
  46. byte    brightnessR = 0,
  47.         brightnessG = 0,
  48.         brightnessB = 0,
  49.         brightnessW = 0;
  50.  
  51. boolean toggleR = 0,
  52.         toggleG = 0,
  53.         toggleB = 0,
  54.         toggleW = 0;
  55.        
  56. boolean fadeOn = 0,
  57.         fadeR = 0,
  58.         fadeG = 0,
  59.         fadeB = 0,
  60.         fadeW = 0;
  61. boolean fadeRtoggle = 0,
  62.         fadeGtoggle = 0,
  63.         fadeBtoggle = 0,
  64.         fadeWtoggle = 0;        
  65. char    fadeStep = 1;
  66. word    fadeDelay = 10,
  67.         fadeDelayStep = 1;
  68.  
  69. boolean strobeOn,
  70.         strobeR,
  71.         strobeG,
  72.         strobeB,
  73.         strobeW = 0;
  74. boolean strobeRtoggle = 0,
  75.         strobeGtoggle = 0,
  76.         strobeBtoggle = 0,
  77.         strobeWtoggle = 0;
  78. char    strobeStep = 10;        
  79. word    strobeDelay = 100;        
  80.  
  81. byte brightness = 0;
  82. //int pauza = 100;
  83.  
  84. //  Sensor dzwięku
  85. int InputSound = 0;
  86. int SoundWaveSensor = 12;
  87. long DetectSpan = 0;
  88. long SoundDetection = 0;
  89.  
  90. boolean lightState = false;
  91.  
  92. /************************************************************FUNKCJE**********/
  93. void beep(word freq, word dur) {
  94.   NewTone(pinBuz, freq, dur);
  95.   //noNewTone(pinBuz);
  96. }
  97.  
  98. void up() {
  99.   if ((brightnessR<=245) && (brightnessR>0)) {
  100.     brightnessR = brightnessR+10;
  101.     setR(brightnessR);
  102.   }
  103.   if ((brightnessG<=245) && (brightnessG>0)) {
  104.     brightnessG = brightnessG+10;
  105.     setG(brightnessG);
  106.   }
  107.   if ((brightnessB<=245) && (brightnessB>0)) {
  108.     brightnessB = brightnessB+10;
  109.     setB(brightnessB);
  110.   }
  111.   if ((brightnessW<=245) && (brightnessW>0)) {
  112.     brightnessW = brightnessW+10;
  113.     setW(brightnessW);
  114.   }
  115.   Serial.println("brightness: ");Serial.println(brightnessR);Serial.println(brightnessG);Serial.println(brightnessB);Serial.println(brightnessW);
  116. //  delay(100);
  117. //  beep(1600, 100);
  118. }
  119.  
  120. void down() {
  121.   if (brightnessR>10) {
  122.     brightnessR = brightnessR-10;
  123.     setR(brightnessR);
  124.   }
  125.   if (brightnessG>=10) {
  126.     brightnessG = brightnessG-10;
  127.     setG(brightnessG);
  128.   }
  129.   if (brightnessB>10) {
  130.     brightnessB = brightnessB-10;
  131.     setB(brightnessB);
  132.   }
  133.   if (brightnessW>10) {
  134.     brightnessW = brightnessW-10;
  135.     setW(brightnessW);
  136.   }
  137.   Serial.println("brightness: ");Serial.println(brightnessR);Serial.println(brightnessG);Serial.println(brightnessB);Serial.println(brightnessW);
  138. //  delay(100);
  139. //  beep(800, 100);
  140. }
  141.  
  142. void on() {
  143.   NewTone(pinBuz, 1600, 60);
  144.   delay(80);
  145.   setRGBW(0,0,0,0);
  146.   while (brightnessW < 255) {
  147.     brightnessW += 1;
  148.     setW(brightnessW);
  149.     delay(5);
  150.   }
  151.   while (brightnessR < 255) {
  152.     brightnessR += 1;
  153.     setR(brightnessR);
  154.     delay(5);
  155.   }
  156.   while (brightnessG < 255) {
  157.     brightnessG += 1;
  158.     setG(brightnessG);
  159.     delay(5);
  160.   }
  161.   while (brightnessB < 255) {
  162.     brightnessB += 1;
  163.     setB(brightnessB);
  164.     delay(5);
  165.   }  
  166.   NewTone(pinBuz, 1600, 60);
  167.  
  168. //  for (unsigned long freq = 50; freq <= 15000; freq += 5) {  
  169. //    NewTone(pinBuz, freq); // Play the frequency (125 Hz to 15 kHz sweep in 10 Hz steps).
  170. //    delay(1); // Wait 1 ms so you can hear it.
  171. //  }
  172. //  noNewTone(pinBuz); // Turn off the tone.  
  173. //  delay(1000);
  174. }
  175.  
  176. void off() {
  177.   setRGBW(0,0,0,0);
  178. //  NewTone(pinBuz, 800, 100);
  179. //  delay(200);
  180. //  NewTone(pinBuz, 800, 100);
  181.   delay(100);
  182.   beep(600, 100);
  183.   delay(200);
  184.   beep(600, 100);
  185.  
  186. }
  187.  
  188. byte setR (byte r) {
  189.   brightnessR = r;
  190.   analogWrite(pinR, brightnessR);
  191.   return (brightnessR);
  192. }
  193.  
  194. byte setG (byte g) {
  195.   brightnessG = g;
  196.   analogWrite(pinG, brightnessG);
  197.   return (brightnessG);
  198. }
  199.  
  200. byte setB (byte b) {
  201.   brightnessB = b;
  202.   analogWrite(pinB, brightnessB);
  203.   return (brightnessB);
  204. }
  205.  
  206. byte setW (byte w) {
  207.   brightnessW = w;
  208.   analogWrite(pinW, brightnessW);
  209.   return (brightnessW);
  210. }
  211.  
  212. void setRGBW (int r, int g, int b, int w) {   //   ta funkcja też sie przyda.
  213.   brightnessR = r;
  214.   brightnessG = g;
  215.   brightnessB = b;
  216.   brightnessW = w;
  217.   analogWrite(pinR, brightnessR);
  218.   analogWrite(pinG, brightnessG);
  219.   analogWrite(pinB, brightnessB);
  220.   analogWrite(pinW, brightnessW);
  221. }
  222.  
  223. //////////////////////////////////////////////////FADE
  224. void fadeFun(byte color) {
  225.   do {
  226.   if (signals.value == FADE7) {
  227.     toggleF = 1;
  228.   } else {
  229.     toggleF = 0;
  230.   }    
  231.   brightness = brightness + fadeStep;
  232.   if (brightness <= 0 || brightness >= 255) {
  233.     fadeStep = -fadeStep;
  234.   }
  235.   if (color == 0) {
  236.     setR(brightness);  
  237.   }
  238.   if (color == 1) {
  239.     setG(brightness);  
  240.   }
  241.   if (color == 2) {
  242.     setB(brightness);  
  243.   }
  244.   if (color == 3) {
  245.     setW(brightness);  
  246.   }
  247.  
  248.   delay(fadeDelay);  
  249.   sygnal();
  250.   if ( (signals.value == OFF) ) {
  251.     off();
  252.     fadeOn = 0;    
  253.     break;
  254.   }  
  255.   if (signals.value == UP) {
  256.     fadeDelay = fadeDelay + fadeDelayStep;
  257.     Serial.println(fadeDelay);
  258.   }
  259.   if (signals.value == DOWN) {
  260.     fadeDelay = fadeDelay - fadeDelayStep;
  261.     Serial.println(fadeDelay);
  262.   }
  263.  
  264.   if (signals.value == RED) {
  265.     off();
  266.     color = 0;
  267.   }
  268.   if (signals.value == GREEN) {
  269.     off();
  270.     color = 1;
  271.   }
  272.   if (signals.value == BLUE) {
  273.     off();
  274.     color = 2;
  275.   }
  276.   if (signals.value == WHITE) {
  277.     off();
  278.     color = 3;
  279.   }
  280.   if ( ((signals.value==FADE7) ) && (toggleF == 0) ) {  //  OFF toggle
  281.     off();
  282.     fadeOn = 0;
  283.     break;
  284.   }  
  285.  
  286.   signals.value = 1;    //reset kodu
  287.  
  288.   } while (fadeOn == 1);
  289. }
  290.  
  291. //void fadeRfun () {
  292. //  do {
  293. //  brightnessR = brightnessR + fadeStep;
  294. //  if (brightnessR <= 0 || brightnessR >= 255) {
  295. //    fadeStep = -fadeStep;
  296. //  }
  297. //  setR(brightnessR);
  298. ////  kod = signals.value;
  299. //  sygnal();
  300. //  delay(fadeDelay);
  301. //
  302. //  if ( (signals.value==16236607) ) {  //  OFF
  303. //    fadeR = 0;
  304. //    setR(0);
  305. //    break;
  306. //  }
  307. //  if (signals.value==16187647) {  //  UP
  308. //    fadeDelay = fadeDelay +1;
  309. //  }
  310. //  if (signals.value==16220287) {  //  DOWN
  311. //    fadeDelay = fadeDelay -1;
  312. //  }
  313. //  Serial.println(fadeDelay);
  314. //  } while (fadeR == 1);  
  315. //}
  316.  
  317.  
  318. //////////////////////////////////////////////////STROBE
  319. void strobeFun (byte color) {
  320.   brightness = 255;
  321.   do {
  322.     if (signals.value == JUMP3) {
  323.       strobeWtoggle = 1;
  324.     } else {
  325.       strobeWtoggle = 0;
  326.     }
  327.  
  328.     if (color == 0) {
  329.       setR(brightness);
  330.       delay(strobeDelay);
  331.       setR(0);
  332.       delay(strobeDelay);      
  333.     }
  334.     if (color == 1) {
  335.       setG(brightness);
  336.       delay(strobeDelay);
  337.       setG(0);
  338.       delay(strobeDelay);      
  339.     }
  340.     if (color == 2) {
  341.       setB(brightness);
  342.       delay(strobeDelay);
  343.       setB(0);
  344.       delay(strobeDelay);      
  345.     }    
  346.     if (color == 3) {
  347.       setW(brightness);
  348.       delay(strobeDelay);
  349.       setW(0);
  350.       delay(strobeDelay);      
  351.     }
  352.        
  353.     sygnal();    
  354.     if (signals.value == OFF) {
  355.       off();
  356.       strobeOn = 0;
  357.       break;
  358.     }
  359.     if ( ((signals.value==JUMP3) ) && (strobeWtoggle == 0) ) {  //  OFF toggle
  360.       off();
  361.       strobeOn = 0;
  362.       break;
  363.     }
  364.     if (signals.value == RED) {
  365.       off();
  366.       color = 0;
  367.     }
  368.     if (signals.value == GREEN) {
  369.       off();
  370.       color = 1;
  371.     }
  372.     if (signals.value == BLUE) {
  373.       off();
  374.       color = 2;
  375.     }
  376.     if (signals.value == WHITE) {
  377.       off();
  378.       color = 3;
  379.     }
  380.                    
  381.     if (signals.value == UP) {
  382.       brightness = brightness + 10;
  383.     }
  384.     if (signals.value == DOWN) {
  385.       brightness = brightness - 10;
  386.     }
  387.  
  388.     if (signals.value == M1) {
  389.       strobeDelay = strobeDelay + strobeStep;
  390.     }
  391.     if (signals.value == M2) {
  392.       if (strobeDelay > strobeStep) {
  393.         strobeDelay = strobeDelay - strobeStep;
  394.       }
  395.     }    
  396.  
  397.     signals.value = 1;
  398.    
  399.   } while ( (strobeOn == 1)  );
  400.  
  401. }
  402.  
  403.  
  404. void sygnal() {
  405.   if (irrecv.decode(&signals)) {
  406.   irrecv.resume();
  407.   }
  408. }
  409.  
  410. void fotorezystor() {
  411.  
  412.   while (signals.value != OFF) {
  413.   fotoR = analogRead(A0);
  414.   Serial.println(fotoR);
  415.   sygnal();
  416.   if (fotoR < 1000) {   //sprawdzic ile jest w dzień
  417.     //brightnessW = fotoR;
  418.     brightnessW = (1000 - fotoR) * 255/1000;
  419.     Serial.print("brightnessW: ");
  420.     Serial.println(brightnessW);
  421.     setW(brightnessW);
  422.   }
  423.   delay(5);
  424.   }
  425. off();
  426.  
  427. }
  428.  
  429. /************************************************************SETUP**********/
  430. void setup() {
  431.   pinMode(pinR, OUTPUT);
  432.   pinMode(pinG, OUTPUT);
  433.   pinMode(pinB, OUTPUT);
  434.   pinMode(pinW, OUTPUT);
  435.  
  436.   pinMode(pinBuz, OUTPUT);
  437.  
  438.   Serial.begin(9600);
  439.   irrecv.enableIRIn(); // włączenie odbierania danych
  440.  
  441.   pinMode(SoundWaveSensor, INPUT);
  442. }
  443. /************************************************************LOOP**********/
  444. void loop() {
  445.  
  446. //  detekcja dzwięku
  447. int sensorState = digitalRead(SoundWaveSensor);
  448.   if (sensorState == 0)  {
  449.     if (InputSound == 0)    {
  450.       SoundDetection = DetectSpan = millis();
  451.       InputSound++;
  452.     }
  453.     else if (InputSound > 0 && millis()-DetectSpan >= 50)    {
  454.       DetectSpan = millis();
  455.       InputSound++;
  456.     }
  457.   }
  458.  
  459.   if (millis()-SoundDetection >= 400)  {
  460.     if (InputSound == 2)    {
  461.       if (!lightState)    {
  462.           lightState = true;
  463.           Serial.println("Switch is Activated");
  464.           on();
  465.         }
  466.         else if (lightState)  {
  467.           lightState = false;
  468.           Serial.println("Switch is Deactivated");
  469.           off();
  470.         }
  471.     }
  472.     InputSound = 0;
  473.   }
  474. // koniec detekcji
  475.  
  476. sygnal();
  477. if (irrecv.decode(&signals)) {
  478.   Serial.println(signals.value);
  479.   irrecv.blink13(true); // mrugamy diodami w arduino (zmieić na zewnetrzna diode)
  480.  
  481. /************************************************************SWITCH**********/
  482. switch (signals.value) {
  483.  
  484. case UP:
  485.   Serial.println("UP");
  486.   up();
  487. break;
  488.  
  489. case DOWN:
  490.   Serial.println("DOWN");
  491.   down();
  492. break;
  493.            
  494. case ON:
  495.   Serial.println("ON");
  496.   on();
  497. //  setR(0);
  498. //  setG(0);
  499. //  setB(0);
  500. //  setW(255);
  501. break;
  502.  
  503. case OFF:
  504.   Serial.println("OFF");
  505.   off();
  506. break;
  507.  
  508. case RED:
  509.   Serial.println("RED");
  510.   if (toggleR==1) {
  511.     setR(0);
  512.     toggleR = 0;
  513.   } else {
  514.     setR(255);
  515.     toggleR = 1;
  516.   }
  517. break;
  518.  
  519. case GREEN:
  520.   Serial.println("GREEN");
  521.   if (toggleG==1) {
  522.     setG(0);
  523.     toggleG = 0;
  524.   } else {
  525.     setG(255);
  526.     toggleG = 1;
  527.   }
  528. break;
  529.  
  530. case BLUE:
  531.   Serial.println("BLUE");
  532.   if (toggleB==1) {
  533.     setB(0);
  534.     toggleB = 0;
  535.   } else {
  536.     setB(255);
  537.     toggleB = 1;
  538.   }
  539. break;
  540.  
  541. case WHITE:
  542.   Serial.println("WHITE");
  543.   if (toggleW==1) {
  544.     setW(0);
  545.     toggleW = 0;
  546.   } else {
  547.     setW(255);
  548.     toggleW = 1;
  549.   }
  550. break;
  551.  
  552. case ORANGE:
  553.   Serial.println("ORANGE");
  554.     setR(255);
  555.     setG(165);
  556.     setB(0);
  557.     setW(0);
  558. break;
  559.  
  560. case YELLOW:
  561.     Serial.println("YELLOW");
  562.     setR(255);
  563.     setG(255);
  564.     setB(0);
  565.     setW(0);
  566. break;
  567.  
  568. case CYAN:
  569.     Serial.println("CYAN");
  570.     setR(0);
  571.     setG(255);
  572.     setB(255);
  573.     setW(0);
  574. break;
  575.  
  576. case PURPLE:
  577.     Serial.println("PURPLE");
  578.     setRGBW(128,0,128,0);
  579. break;
  580.  
  581. case JUMP3:
  582.     Serial.println("JUMP3");
  583.     strobeOn = 1;
  584. break;
  585.  
  586. case JUMP7:
  587.     Serial.println("JUMP7");
  588. break;
  589.  
  590. case FADE3:
  591.     Serial.println("FADE3");
  592. break;
  593.  
  594. case FADE7:
  595.     Serial.println("FADE7");
  596.     fadeOn = 1;
  597. break;
  598.  
  599.  
  600. case M1:
  601.     Serial.println("M1 Fotorezystor");
  602.     fotorezystor();
  603. break;
  604.  
  605.   case M2:
  606.  
  607.   break;
  608.  
  609.   case M3:
  610.  
  611.   break;
  612.  
  613.   case M4:
  614.  
  615.   break;
  616. }
  617. // KONIEC SWITCH
  618.  
  619. /************************************************************FADE*/
  620. if (fadeOn == 1) {
  621.   fadeFun(3); //  domyślnie biały
  622. }
  623.  
  624. /************************************************************STROBE*/
  625. if (strobeOn == 1) {
  626.   strobeFun(3);
  627. }
  628.  
  629. //delay(10);
  630. irrecv.resume(); // nasłuchujemy na następne nadanie
  631. }
  632. }
RAW Paste Data