AubsProg

#include <FastLED.h>
#define NUM_LEDS 84
#define DATA_PIN 3
#define WAVELENGTH 400 // # of steps peak-to-peak 
#define MAX_BRIGHTNESS 255.0   // max brightness 0-255
#define CYCLE_TIME 150   // delay before updating colors, in ms
#define FLASH_TIME 50   // delay before rewriting outputs (Useful for fading)
#define SCALING_FACTOR 20 //The phase distance in waveform between the each LED
#define FADE_DURATION 1200 //The time it takes to fade between on and off
#define BUTTON_PIN 8  // the number of the pushbutton pin

class ButtCheck {


  public:           // Access specifier
    unsigned long buttonStartTime = 0; //Start time since the button has been high, with debounce control
    unsigned long lastTimeCheck = 0;
    int debCount; //debounce buffer counter.  zero = button is off
    const int debBufferMax = 6; //button has to be low for at least 50 ms to be registered as off
    const int timeCheckInterval = 1; //
    int myButtonPinNum; //what button pin number is it that I'm watching 
    
    ButtCheck(int tempButt) {     // Constructor
      myButtonPinNum = tempButt;
    }

    int timeButtPush() {
      
      unsigned long currTimeCheck = millis();  //temp var to get current time
      //if sufficient time has passed since the last time check
      if (currTimeCheck - lastTimeCheck >= timeCheckInterval) {
        lastTimeCheck = currTimeCheck;
        //if button is pushed
        if (digitalRead(myButtonPinNum)) { //if reads button as high
          if (debCount == 0) { //first signal that the button has been pushed.  So, set the start time as now
            buttonStartTime = currTimeCheck;
          }
          debCount = debCount + 2;
          
          if (debCount > debBufferMax) {
            debCount = debBufferMax;
          } 
        } else { //if reads button as low
          debCount = debCount - 1;
        }
      }
      if (debCount <= 0) {//debounce buffer has run out, so assume button was actually released
        debCount = 0;
        return 0;
      }
      int tempInt = currTimeCheck - buttonStartTime;
      return tempInt;
    }

};

/*
  we're going to use a triangle wave that's truncated below 0, like so:
  MAX |\                  /\
      | \                /  \
      |  \              /    \
      |   \            /      \
  0___|____\__________/________\_
      |

  but then overlay 3 of these, one each for R, G, B:
      R    G    B         R    G
  MAX |\   /\   /\  oops  /\   /\
      | \ /  \ /  \      /  \ /
      |  X    X    \    /    X
      | / \  / \    \  /    / \
  0___|/___\/___\____\/____/___\_
      |

  so really we want to cut off half of the negative (zero) part of the cycle:
  MAX |\             /\
      | \           /  \
      |  \         /    \
      |   \       /      \
  0___|____\_____/________\_
      |

  for this pattern:
      R    G    B    R    G    B
  MAX |\   /\   /\   /\   /\   /\
      | \ /  \ /  \ /  \ /  \ /
      |  X    X    X    X    X
      | / \  / \  / \  / \  / \
  0___|/___\/___\/___\/___\/___\/_
      |

  so, using WAVELENGTH and MAXBRIGHT, we precalculate an array of values sampled
  from the conceptual (dis)continuous function, then shift along those at each
  step, with a different offset for each color
*/

CRGB leds[NUM_LEDS];
int Ridx;
int Gidx;
int Bidx;
int tempRidx;
int tempGidx;
int tempBidx;

int brightness = 255;

unsigned long cyclePrevTime = 0;
unsigned long flashPrevTime = 0;

ButtCheck myTouchSense(BUTTON_PIN);

bool lightsOn = 1; //default on
bool lightOnModeLatch = 0; //For tracking if the lighton has already been switched
bool redMode = 0; //default off
bool redModeLatch = 0; //For tracking if the redmode has already been switched
int lastButtonTime; 

bool fadingToBlack = 0;
bool fadingToLight = 1;
int fadeStartTime = 0;
int fadeScale = 255;


byte waveform[WAVELENGTH];


void setup() {
  pinMode(BUTTON_PIN, INPUT);
  //Serial.begin(9600);
  //Serial.println("Hi");
  FastLED.addLeds<WS2811, DATA_PIN>(leds, NUM_LEDS);

  // TODO: delete most of this code by using the FastLED triwave8() func
  //       also look into other provided funcs
  //       (maybe beatsin8 would be even better?)

  /*
    start moving upward from the wave minimum, so we're going to generate this:
    MAX |     /\
        |    /  \
    0___|___/____\_
  */

  double slope = (double) (1) / (WAVELENGTH / 3);
  double val = -1;
  //Serial.print("slope = "); Serial.println(slope);
  for (int i=0; i < WAVELENGTH; i++) {
    // TODO: probably going to be some errors in here
    // wrt int -> double -> int conversion
    
    // clamp to 0 while val is negative
    if (val >= 0) {
      waveform[i] = floor(pow(val,2) * 255.0);
    } else {
      waveform[i] = 1;
    }

    val = val + slope;

    // once we hit max, start going down
    if (val >= 1) {
      val = 1;
      slope *= -1;
    }
    //Serial.print("i: "); Serial.print(i); Serial.print(" = "); Serial.println(waveform[i]);
  }
  // these offsets will make the cycle start at 100% red,
  // as in the diagram above
  Ridx = (2 * WAVELENGTH) / 3;
  Gidx = WAVELENGTH / 3;
  Bidx = 0;

  fadeStartTime = millis(); //DELETE ME maybe
}

void loop() {

  //int currentButtonTime = myTouchSense.timeButtPush(); //This is zero if the button is released

  //Serial.print("last: "); Serial.print(lastButtonTime); Serial.print(", now: "); Serial.println(currentButtonTime);

  if (fadingToLight) {
    fadeToLight();
  }

  if (fadingToBlack) {
    fadeToBlack();
  }

  if (lightsOn) {
    lightsCycle();
  }

  if (myTouchSense.timeButtPush() > 1000 && redModeLatch == 0) { //switch modes if released for longer than 3 secs
      redMode = !redMode;
      redModeLatch = 1;
  } else if (myTouchSense.timeButtPush() > 2000 && lightOnModeLatch == 0) { //power off if released for between .1 and 5 secs
    lightsOn = !lightsOn;
    lightOnModeLatch = 1;
    redMode = 0;
    if (lightsOn) { //turn lights on
      fadingToLight = 1;
      fadeStartTime = millis();
      fadeScale = 0;
    } else { //turn lights off
      fadeScale = 0;
      FastLED.setBrightness(fadeScale);
      FastLED.show();
    }
  }



  if (myTouchSense.timeButtPush() == 0) { //Button low
    redModeLatch = 0;
    lightOnModeLatch = 0;
  }

}

void fadeToBlack() {
  float temp = (float) (millis() - fadeStartTime) / FADE_DURATION;
  if (temp > 1.0) {
    temp = 1.0;
    fadingToBlack = 0; 
  }
  temp = 1.0 - temp;
  temp = pow(temp, 4.0);
  fadeScale = temp * MAX_BRIGHTNESS;

}

void fadeToLight() {
  float temp = (float) (millis() - fadeStartTime) / FADE_DURATION;
  if (temp > 1.0) { //Fully faded
    temp = 1.0;
    fadingToLight = 0; 
  }
  temp = pow(temp, 2.0);
  fadeScale = temp * MAX_BRIGHTNESS;

}

void lightsCycle() {
  

    unsigned long currTime = millis();
    if (currTime - cyclePrevTime > CYCLE_TIME) {  //Only do the lightcycle if enough time has passed
      cyclePrevTime = currTime;
      for(int n=0; n < NUM_LEDS; n++) {
        // scan through the full waveform to assign a different value
        // to each LED, looping back to the start as necessary, separating them out by the scaling factor
        tempRidx = (Ridx + n*SCALING_FACTOR) % WAVELENGTH;
        tempGidx = (Gidx + n*SCALING_FACTOR) % WAVELENGTH;
        tempBidx = (Bidx + n*SCALING_FACTOR) % WAVELENGTH;
        //led.r is actually blue, g is actually red, and b is actually green

        if (redMode) {
          leds[n].r = 0;
          
          leds[n].b = waveform[tempGidx] * 0.4;
          if (waveform[tempBidx] > waveform[tempRidx]) {
            leds[n].g = waveform[tempBidx];
          } else {
            leds[n].g = waveform[tempRidx]; 
          }
        } else {
          leds[n].r = waveform[tempBidx];
          leds[n].b = waveform[tempGidx];
          leds[n].g = waveform[tempRidx]; 
        }
      }

      Ridx = (Ridx + 1) % WAVELENGTH;
      Gidx = (Gidx + 1) % WAVELENGTH;
      Bidx = (Bidx + 1) % WAVELENGTH;
    }

    if (currTime - flashPrevTime > FLASH_TIME) {  //Only do the flash if enough time has passed
      flashPrevTime = currTime;
      FastLED.setBrightness(fadeScale);
      FastLED.show();
  }
}