LedStripRemote

#include <IRremote.h>
byte pinIr = 11;
IRrecv irrecv(pinIr);
decode_results signals;

#include <NewTone.h>
byte pinBuz = 2;

int fotoR = 0;
boolean toggleF = 0;

//  kody pilota
#define UP 16187647
#define DOWN 16220287
#define ON 16203967
#define OFF 16236607
//#define OFFHOLD 4294967295

#define RED 16195807
#define GREEN 16228447
#define BLUE 16212127
#define WHITE 16244767

#define ORANGE 16191727
#define YELLOW 16224367
#define CYAN 16208047
#define PURPLE 16240687

#define JUMP3 16199887
#define JUMP7 16232527
#define FADE3 16216207
#define FADE7 16248847

#define M1 16189687
#define M2 16222327
#define M3 16206007
#define M4 16238647

//  piny RGBW
byte  pinR = 5;
byte  pinG = 6;
byte  pinB = 9;
byte  pinW = 10 ;

//  jasność diód (pwm 0-255)
byte    brightnessR = 0,
        brightnessG = 0,
        brightnessB = 0,
        brightnessW = 0;

boolean toggleR = 0,
        toggleG = 0,
        toggleB = 0,
        toggleW = 0;

boolean fadeOn = 0,
        fadeR = 0,
        fadeG = 0,
        fadeB = 0,
        fadeW = 0;
boolean fadeRtoggle = 0,
        fadeGtoggle = 0,
        fadeBtoggle = 0,
        fadeWtoggle = 0;
char    fadeStep = 1;
word    fadeDelay = 10,
        fadeDelayStep = 1;

boolean strobeOn,
        strobeR,
        strobeG,
        strobeB,
        strobeW = 0;
boolean strobeRtoggle = 0,
        strobeGtoggle = 0,
        strobeBtoggle = 0,
        strobeWtoggle = 0;
char    strobeStep = 10;
word    strobeDelay = 100;

byte brightness = 0;
//int pauza = 100;

//  Sensor dzwięku
int InputSound = 0;
int SoundWaveSensor = 12;
long DetectSpan = 0;
long SoundDetection = 0;

boolean lightState = false;

/************************************************************FUNKCJE**********/
void beep(word freq, word dur) {
  NewTone(pinBuz, freq, dur);
  //noNewTone(pinBuz);
}

void up() {
  if ((brightnessR<=245) && (brightnessR>0)) {
    brightnessR = brightnessR+10;
    setR(brightnessR);
  }
  if ((brightnessG<=245) && (brightnessG>0)) {
    brightnessG = brightnessG+10;
    setG(brightnessG);
  }
  if ((brightnessB<=245) && (brightnessB>0)) {
    brightnessB = brightnessB+10;
    setB(brightnessB);
  }
  if ((brightnessW<=245) && (brightnessW>0)) {
    brightnessW = brightnessW+10;
    setW(brightnessW);
  }
  Serial.println("brightness: ");Serial.println(brightnessR);Serial.println(brightnessG);Serial.println(brightnessB);Serial.println(brightnessW);
//  delay(100);
//  beep(1600, 100);
}

void down() {
  if (brightnessR>10) {
    brightnessR = brightnessR-10;
    setR(brightnessR);
  }
  if (brightnessG>=10) {
    brightnessG = brightnessG-10;
    setG(brightnessG);
  }
  if (brightnessB>10) {
    brightnessB = brightnessB-10;
    setB(brightnessB);
  }
  if (brightnessW>10) {
    brightnessW = brightnessW-10;
    setW(brightnessW);
  }
  Serial.println("brightness: ");Serial.println(brightnessR);Serial.println(brightnessG);Serial.println(brightnessB);Serial.println(brightnessW);
//  delay(100);
//  beep(800, 100);
}

void on() {
  NewTone(pinBuz, 1600, 60);
  delay(80);
  setRGBW(0,0,0,0);
  while (brightnessW < 255) {
    brightnessW += 1;
    setW(brightnessW);
    delay(5);
  }
  while (brightnessR < 255) {
    brightnessR += 1;
    setR(brightnessR);
    delay(5);
  }
  while (brightnessG < 255) {
    brightnessG += 1;
    setG(brightnessG);
    delay(5);
  }
  while (brightnessB < 255) {
    brightnessB += 1;
    setB(brightnessB);
    delay(5);
  }
  NewTone(pinBuz, 1600, 60);

//  for (unsigned long freq = 50; freq <= 15000; freq += 5) {
//    NewTone(pinBuz, freq); // Play the frequency (125 Hz to 15 kHz sweep in 10 Hz steps).
//    delay(1); // Wait 1 ms so you can hear it.
//  }
//  noNewTone(pinBuz); // Turn off the tone.
//  delay(1000);
}

void off() {
  setRGBW(0,0,0,0);
//  NewTone(pinBuz, 800, 100);
//  delay(200);
//  NewTone(pinBuz, 800, 100);
  delay(100);
  beep(600, 100);
  delay(200);
  beep(600, 100);

}

byte setR (byte r) {
  brightnessR = r;
  analogWrite(pinR, brightnessR);
  return (brightnessR);
}

byte setG (byte g) {
  brightnessG = g;
  analogWrite(pinG, brightnessG);
  return (brightnessG);
}

byte setB (byte b) {
  brightnessB = b;
  analogWrite(pinB, brightnessB);
  return (brightnessB);
}

byte setW (byte w) {
  brightnessW = w;
  analogWrite(pinW, brightnessW);
  return (brightnessW);
}

void setRGBW (int r, int g, int b, int w) {   //   ta funkcja też sie przyda.
  brightnessR = r;
  brightnessG = g;
  brightnessB = b;
  brightnessW = w;
  analogWrite(pinR, brightnessR);
  analogWrite(pinG, brightnessG);
  analogWrite(pinB, brightnessB);
  analogWrite(pinW, brightnessW);
}

//////////////////////////////////////////////////FADE
void fadeFun(byte color) {
  do {
  if (signals.value == FADE7) {
    toggleF = 1;
  } else {
    toggleF = 0;
  }
  brightness = brightness + fadeStep;
  if (brightness <= 0 || brightness >= 255) {
    fadeStep = -fadeStep;
  }
  if (color == 0) {
    setR(brightness);
  }
  if (color == 1) {
    setG(brightness);
  }
  if (color == 2) {
    setB(brightness);
  }
  if (color == 3) {
    setW(brightness);
  }

  delay(fadeDelay);
  sygnal();
  if ( (signals.value == OFF) ) {
    off();
    fadeOn = 0;
    break;
  }
  if (signals.value == UP) {
    fadeDelay = fadeDelay + fadeDelayStep;
    Serial.println(fadeDelay);
  }
  if (signals.value == DOWN) {
    fadeDelay = fadeDelay - fadeDelayStep;
    Serial.println(fadeDelay);
  }

  if (signals.value == RED) {
    off();
    color = 0;
  }
  if (signals.value == GREEN) {
    off();
    color = 1;
  }
  if (signals.value == BLUE) {
    off();
    color = 2;
  }
  if (signals.value == WHITE) {
    off();
    color = 3;
  }
  if ( ((signals.value==FADE7) ) && (toggleF == 0) ) {  //  OFF toggle
    off();
    fadeOn = 0;
    break;
  }

  signals.value = 1;    //reset kodu

  } while (fadeOn == 1);
}

//void fadeRfun () {
//  do {
//  brightnessR = brightnessR + fadeStep;
//  if (brightnessR <= 0 || brightnessR >= 255) {
//    fadeStep = -fadeStep;
//  }
//  setR(brightnessR);
////  kod = signals.value;
//  sygnal();
//  delay(fadeDelay);
//
//  if ( (signals.value==16236607) ) {  //  OFF
//    fadeR = 0;
//    setR(0);
//    break;
//  }
//  if (signals.value==16187647) {  //  UP
//    fadeDelay = fadeDelay +1;
//  }
//  if (signals.value==16220287) {  //  DOWN
//    fadeDelay = fadeDelay -1;
//  }
//  Serial.println(fadeDelay);
//  } while (fadeR == 1);
//}


//////////////////////////////////////////////////STROBE
void strobeFun (byte color) {
  brightness = 255;
  do {
    if (signals.value == JUMP3) {
      strobeWtoggle = 1;
    } else {
      strobeWtoggle = 0;
    }

    if (color == 0) {
      setR(brightness);
      delay(strobeDelay);
      setR(0);
      delay(strobeDelay);
    }
    if (color == 1) {
      setG(brightness);
      delay(strobeDelay);
      setG(0);
      delay(strobeDelay);
    }
    if (color == 2) {
      setB(brightness);
      delay(strobeDelay);
      setB(0);
      delay(strobeDelay);
    }
    if (color == 3) {
      setW(brightness);
      delay(strobeDelay);
      setW(0);
      delay(strobeDelay);
    }

    sygnal();
    if (signals.value == OFF) {
      off();
      strobeOn = 0;
      break;
    }
    if ( ((signals.value==JUMP3) ) && (strobeWtoggle == 0) ) {  //  OFF toggle
      off();
      strobeOn = 0;
      break;
    }
    if (signals.value == RED) {
      off();
      color = 0;
    }
    if (signals.value == GREEN) {
      off();
      color = 1;
    }
    if (signals.value == BLUE) {
      off();
      color = 2;
    }
    if (signals.value == WHITE) {
      off();
      color = 3;
    }

    if (signals.value == UP) {
      brightness = brightness + 10;
    }
    if (signals.value == DOWN) {
      brightness = brightness - 10;
    }

    if (signals.value == M1) {
      strobeDelay = strobeDelay + strobeStep;
    }
    if (signals.value == M2) {
      if (strobeDelay > strobeStep) {
        strobeDelay = strobeDelay - strobeStep;
      }
    }

    signals.value = 1;

  } while ( (strobeOn == 1)  );

}


void sygnal() {
  if (irrecv.decode(&signals)) {
  irrecv.resume();
  }
}

void fotorezystor() {

  while (signals.value != OFF) {
  fotoR = analogRead(A0);
  Serial.println(fotoR);
  sygnal();
  if (fotoR < 1000) {   //sprawdzic ile jest w dzień
    //brightnessW = fotoR;
    brightnessW = (1000 - fotoR) * 255/1000;
    Serial.print("brightnessW: ");
    Serial.println(brightnessW);
    setW(brightnessW);
  }
  delay(5);
  }
off();

}

/************************************************************SETUP**********/
void setup() {
  pinMode(pinR, OUTPUT);
  pinMode(pinG, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinW, OUTPUT);

  pinMode(pinBuz, OUTPUT);

  Serial.begin(9600);
  irrecv.enableIRIn(); // włączenie odbierania danych

  pinMode(SoundWaveSensor, INPUT);
}
/************************************************************LOOP**********/
void loop() {

//  detekcja dzwięku
int sensorState = digitalRead(SoundWaveSensor);
  if (sensorState == 0)  {
    if (InputSound == 0)    {
      SoundDetection = DetectSpan = millis();
      InputSound++;
    }
    else if (InputSound > 0 && millis()-DetectSpan >= 50)    {
      DetectSpan = millis();
      InputSound++;
    }
  }

  if (millis()-SoundDetection >= 400)  {
    if (InputSound == 2)    {
      if (!lightState)    {
          lightState = true;
          Serial.println("Switch is Activated");
          on();
        }
        else if (lightState)  {
          lightState = false;
          Serial.println("Switch is Deactivated");
          off();
        }
    }
    InputSound = 0;
  }
// koniec detekcji

sygnal();
if (irrecv.decode(&signals)) {
  Serial.println(signals.value);
  irrecv.blink13(true); // mrugamy diodami w arduino (zmieić na zewnetrzna diode)

/************************************************************SWITCH**********/
switch (signals.value) {

case UP:
  Serial.println("UP");
  up();
break;

case DOWN:
  Serial.println("DOWN");
  down();
break;

case ON:
  Serial.println("ON");
  on();
//  setR(0);
//  setG(0);
//  setB(0);
//  setW(255);
break;

case OFF:
  Serial.println("OFF");
  off();
break;

case RED:
  Serial.println("RED");
  if (toggleR==1) {
    setR(0);
    toggleR = 0;
  } else {
    setR(255);
    toggleR = 1;
  }
break;

case GREEN:
  Serial.println("GREEN");
  if (toggleG==1) {
    setG(0);
    toggleG = 0;
  } else {
    setG(255);
    toggleG = 1;
  }
break;

case BLUE:
  Serial.println("BLUE");
  if (toggleB==1) {
    setB(0);
    toggleB = 0;
  } else {
    setB(255);
    toggleB = 1;
  }
break;

case WHITE:
  Serial.println("WHITE");
  if (toggleW==1) {
    setW(0);
    toggleW = 0;
  } else {
    setW(255);
    toggleW = 1;
  }
break;

case ORANGE:
  Serial.println("ORANGE");
    setR(255);
    setG(165);
    setB(0);
    setW(0);
break;

case YELLOW:
    Serial.println("YELLOW");
    setR(255);
    setG(255);
    setB(0);
    setW(0);
break;

case CYAN:
    Serial.println("CYAN");
    setR(0);
    setG(255);
    setB(255);
    setW(0);
break;

case PURPLE:
    Serial.println("PURPLE");
    setRGBW(128,0,128,0);
break;

case JUMP3:
    Serial.println("JUMP3");
    strobeOn = 1;
break;

case JUMP7:
    Serial.println("JUMP7");
break;

case FADE3:
    Serial.println("FADE3");
break;

case FADE7:
    Serial.println("FADE7");
    fadeOn = 1;
break;


case M1:
    Serial.println("M1 Fotorezystor");
    fotorezystor();
break;

  case M2:

  break;

  case M3:

  break;

  case M4:

  break;
}
// KONIEC SWITCH

/************************************************************FADE*/
if (fadeOn == 1) {
  fadeFun(3); //  domyślnie biały
}

/************************************************************STROBE*/
if (strobeOn == 1) {
  strobeFun(3);
}

//delay(10);
irrecv.resume(); // nasłuchujemy na następne nadanie
}
}