/*
Animated LED cloud with multiple weather patterns
Connect a strip of addressable LEDs to an arduino with GND to GND, LED power to Vin, and LED data to Pin 6
Tested on an Arduino Uno with Adafruit neopixels. Will work with other strips, but 
will require changes to the the "strip" settings below.

With 30 LEDs, it can be powered over USB, or a good 2A external phone charging battery connected to the arduino.

To build, place in a folder named "Cloud_Main", open "Cloud_Main.ino" with the Arduino IDE.
In the Arduino IDE, select your matching board, and use the plugin manager to install the Adafruit_NeoPixel library.

To construct a cloud, tape 2 wire coat hangers together, both upright with a right angle between them.
Tape the Arduino up near the hooks, and arrange the LED strip to wind throughout the volume, facing outwards as
much as possible.

Then fill that volume with polyester fill (which goes in stuffed animals) to cover the LEDs. Clear tape can help
keep the cloud together. Arrange the polyfill so that the hangers and LED strip are hidden.
*/

#include <Adafruit_NeoPixel.h>
#define PIN 14
#define ledCount 60


Adafruit_NeoPixel strip = Adafruit_NeoPixel(ledCount, PIN, NEO_GRB + NEO_KHZ800); //first number controls the amount of pixels you have (add 4 so the drip falls off the edge)
//Adafruit_NeoPixel stripOld = Adafruit_NeoPixel(ledCount, 7, NEO_GRB + NEO_KHZ800);
//Adafruit_Neopixel stripNew = Adafruit_NeoPixel(ledCount, 8, NEO_GRB + NEO_KHZ800);
int oldR[ledCount];
int oldG[ledCount];
int oldB[ledCount];

int newR[ledCount];
int newG[ledCount];
int newB[ledCount];
int nmax = 255;


//---LED FX VARS
int idex = 0;                //-LED INDEX (0 to LED_COUNT-1
int ihue = 150;                //-HUE (0-255)
int ibright = 50;             //-BRIGHTNESS (0-255)
int isat = 240;                //-SATURATION (0-255)
int bouncedirection = 0;     //-SWITCH FOR COLOR BOUNCE (0-1)
float tcount = 0.0;          //-INC VAR FOR SIN LOOPS
int lcount = 0;              //-ANOTHER COUNTING VAR
int TOP_INDEX = ledCount/2;
int BOTTOM_INDEX = 0;
int thissat = 255;
int EVENODD = ledCount%2;
int tijd = 0;
int sunnyBrightness = 200;

int star1Loc = 6;  // not used
int star2Loc = 30; // not used
int moonLoc = 2;  // not used

void setup() {
  Serial.begin(9600); // open the serial port at 9600 bps:
  
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
  randomSeed(analogRead(0)); //EXTRA RANDOMNESS!!!!!
  
}
void loop() {
  boolean DemoMode = true;
  
  if(DemoMode){
    long tijd = millis();
    tijd /= 10000;
        switch (tijd % 15){
      case 0:
        HexLights();
        break;
      case 1:
        diamond();
        break;
      case 2:
        pastel_propeller();
        break;
      case 3:
        random_index();
        break;
      case 4:
       random_blue();
        break;
      case 5:
        blue_flower(); 
        break;
      case 6:
        pink_sparkles(); 
        break;
      case 7:
        blue_cycle(); //springt hard terug zou in reverse moeten    
      
    }
  }
    else{ //set DemoMode false and test functions here!
         //blue_cycle();
         //pink_sparkles();
         //diamond();   
         //pastel_propeller();
         // random_index(); // niet zo boeiend
         //blue_flower(); 
         // random_blue();
         // HexLights();
         //ZeroLight();
         
          
    }
  }
 
    
    
//============================my voids===========================================================
  void HexLights(){
    int num_sections = 6;
    int zero_led = 6;
    
    for(int i = 0; i < ledCount; i++) {
      int Hue = (floor(((i-zero_led+ledCount)%ledCount)/(ledCount/num_sections))) * 360/num_sections;
      setHSV(i, Hue, 255, 255);
    }
      //Serial.println((i-zero_led+ledCount)%ledCount);
 
    strip.show();
    //delay(10); 

     }//void HexLights
  
//==================================================================================================
  void blue_flower(){                   
    int num_sections = 6;
    int zero_led = 6;
    
    for(int i = 0; i < ledCount; i++) {
      int baseColor = 180;
      int N10  = (ledCount/6);
      int N20  = (ledCount/3);  
      int N30 = (ledCount/2); 
      int N40 = (ledCount-N20);
      int N50 = (ledCount-N10); 
      setHSV(i, baseColor, 255, 255);
       if(i == 0) baseColor = 220;
        if(i == N10) baseColor = 220;
         if(i == N20) baseColor = 220;
          if(i == N30) baseColor = 220;
           if(i == N40) baseColor = 220;
             if(i == N50) baseColor = 220; 
             setHSV(i, baseColor, 255, 255);
             
  if(i == 0 + ledCount/9) baseColor = 0;
        if(i == N10 + ledCount/9) baseColor = 160;
         if(i == N20 + ledCount/9) baseColor = 160;
          if(i == N30 + ledCount/9) baseColor = 160;
           if(i == N40 + ledCount/9) baseColor = 160;
             if(i == N50 + ledCount/9) baseColor = 160; 
             setHSV(i, baseColor, 100, 255);
  
}
    strip.show();
    //delay(10); 
  
  }//void blue_flower
  
  //============================================================

void diamond(){
  for(int i = 0; i< ledCount;i++){
    newR[i] = random(0,150);//redish
    newG[i] = random(50,256);
    newB[i] = random(150,256);
  }
  
  for(int n = 0; n < 256; n++){  //update over time
    for(int i=0;i<ledCount;i++){    //update each pixel
      int thisR = map(n,0,nmax,oldR[i],newR[i]);
      int thisG = map(n,0,nmax,oldG[i],newG[i]);
      int thisB = map(n,0,nmax,oldB[i],newB[i]);
      strip.setPixelColor(i,thisR,thisG,thisB);
    }
    strip.show();
    //delay(10);
  }
  
  for(int i = 0; i< ledCount;i++){
    oldR[i] = newR[i];
    oldG[i] = newG[i];
    oldB[i] = newB[i];
  }
} // void diamond

  //============================================================
byte SparklingR[] = {0,40,10,0,20,30,0,10,20};
byte SparklingG[] = {150,200,255,180,220,160,255,200,250};
byte SparklingB[] = {255,255,200,255,255,255,200,255,255};

void random_blue(){
  for(int i = 0; i< ledCount;i++){
    int matrixPos = random(10);
    newR[i] = SparklingR[matrixPos];
    newG[i] = SparklingG[matrixPos];
    newB[i] = SparklingB[matrixPos];
  }
  
  for(int n = 0; n < 256; n++){  //update over time
    for(int i=0;i<ledCount;i++){    //update each pixel
      int thisR = map(n,0,nmax,oldR[i],newR[i]);
      int thisG = map(n,0,nmax,oldG[i],newG[i]);
      int thisB = map(n,0,nmax,oldB[i],newB[i]);
      strip.setPixelColor(i,thisR,thisG,thisB);
    }
    strip.show();
    //delay(10);
  }
  
  for(int i = 0; i< ledCount;i++){
    oldR[i] = newR[i];
    oldG[i] = newG[i];
    oldB[i] = newB[i];
  }
  
}//void random_blue
//============================================================

void random_index() {                        //niet heel inspirerend 
  int idex = random(0, ledCount);
  int ihue = random(0, 255);  
  //leds[idex] = CHSV(ihue, thissat, 255);
  setHSV(idex,ihue,200,50);
  strip.show();
  delay(100);
  
}//void random_index

//============================================================


void pastel_propeller() {                          
  idex++;
  int thishue = 180;
  int thisdelay = 100;
  int ghue = (thishue + 40) % 255;
  int bhue = (thishue + 70) % 255;
  int N3  = int(ledCount/3);
  int N6  = int(ledCount/6);  
  int N12 = int(ledCount/12);  
  for(int i = 0; i < N3; i++ ) {
    int j0 = (idex + i + ledCount - N12) % ledCount;
    int j1 = (j0+N3) % ledCount;
    int j2 = (j1+N3) % ledCount;    
    //leds[j0] = CHSV(thishue, thissat, 255);
    setHSV(j0,thishue,thissat,255);
    //leds[j1] = CHSV(ghue, thissat, 255);
    setHSV(j1,ghue,thissat,255);
    //leds[j2] = CHSV(bhue, thissat, 255);
    setHSV(j2,bhue,thissat,255);    
  }
  strip.show();    
  delay(thisdelay);  
  
}//void pastel_propeller


//============================================================
void blue_cycle(){                                        //nog hakkerig - moet reverse in de cycle
  for(int i = 160;i<225;i++){
      setAllHSV(i,255,255);
      delay(100);
      strip.show();
  }
}


//============================================================
void pink_sparkles(){
  for(int i = 0; i< ledCount;i++){
    int shade = random(10,255);
    newR[i] = shade-50;
    newG[i] = shade;
    newB[i] = 255;
  }
  
  for(int n = 0; n < 256; n++){  //update over time
    for(int i=0;i<ledCount;i++){    //update each pixel
      int thisR = map(n,0,nmax,oldR[i],newR[i]);
      int thisG = map(n,0,nmax,oldG[i],newG[i]);
      int thisB = map(n,0,nmax,oldB[i],newB[i]);
      strip.setPixelColor(i,thisR,thisG,thisB);
    }
    strip.show();
    delay(5);
  }
  
  for(int i = 0; i< ledCount;i++){
    oldR[i] = newR[i];
    oldG[i] = newG[i];
    oldB[i] = newB[i];
  }
}

  //============================================================
//
// void Hexlights without zero(){
// int num_sections = 6;
// }    
// for(int i = 0; i < ledCount; i++) {
// setHSV(i, (floor(i/(ledCount/num_sections))) * 360/num_sections, 255, 255); 
// }
//    
// strip.show();
//    //delay(10); 
//  
// }//void HexLights without zero

// //Find the zero'th light
//void ZeroLight(){    
//for(int i = 0; i < ledCount; i++) {
//int baseColor = 180;
//if(i == 5) baseColor = 0;
// setHSV(i, baseColor, 255, 255); 
//}
//    
//strip.show();
// }//void ZeroLight


  
//============================EFFECTS from the original===========================================================


void lightning(int length, int hue, int sat){ //200,240,128 is nice and blueish
  for(int i = 0; i<length;i++){
    flicker(hue, sat);
    strip.show();
  }
}


void flicker(int thishue, int thissat) {            //-m9-FLICKER EFFECT
  int random_bright = random(0,255);
  int random_delay = random(10,100);
  int random_bool = random(random_bright);
  if (random_bool < 10) {
    delay(random_delay);
    for(int i = 0 ; i < ledCount; i++ ) {
      setHSV(i, thishue, thissat, random_bright); 
    }
  }
}

void one_color_RGB(char R, char G, char B){      //set all to one RGB
  for(int i = 0; i < ledCount; i++){
    strip.setPixelColor(i,R,G,B);
  }
  strip.show();
}

void flame() {                                    //-m22-FLAMEISH EFFECT
  int idelay = random(0,35);
  float hmin = 0.1; float hmax = 45.0;
  float hdif = hmax-hmin;
  int randtemp = random(0,3);
  float hinc = (hdif/float(TOP_INDEX))+randtemp;
  int ihue = hmin;
  for(int i = 0; i <= TOP_INDEX; i++ ) {
    ihue = ihue + hinc;
    //leds[i] = CHSV(ihue, thissat, 255);
    setHSV(i,ihue,thissat,30);
    int ih = horizontal_index(i);    
    //leds[ih] = CHSV(ihue, thissat, 255);    
    setHSV(ih,ihue,thissat,30);
    //leds[TOP_INDEX].r = 255; leds[TOP_INDEX].g = 255; leds[TOP_INDEX].b = 255;  
    //strip.setPixelColor(TOP_INDEX, 255,255,255);  //Don't need no white pixel on top
    strip.show();    
    delay(idelay);
  }
}


void ems_lightsSTROBE() {                  //-m26-EMERGENCY LIGHTS (STROBE LEFT/RIGHT)
  int thishue = 0;
  int thathue = (thishue + 160) % 255;
  int thisdelay = 100;
  for(int x = 0 ; x < 5; x++ ) {
    for(int i = 0 ; i < TOP_INDEX; i++ ) {
        //leds[i] = CHSV(thishue, thissat, 255);
        setHSV(i,thishue,thissat,255);
    }
    strip.show(); delay(thisdelay); 
    one_color_RGB(0, 0, 0);
    strip.show(); delay(thisdelay);
  }
  for(int x = 0 ; x < 5; x++ ) {
    for(int i = TOP_INDEX ; i < ledCount; i++ ) {
        //leds[i] = CHSV(thathue, thissat, 255);
        setHSV(i,thathue,thissat,255);
    }
    strip.show(); delay(thisdelay);
    one_color_RGB(0, 0, 0);
    strip.show(); delay(thisdelay);
  }
}


void rainbowCycle(uint8_t wait) {          //Rainbow
  uint16_t i, j;

  for(j=0; j<256*10; j++) { // 10 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {        //wheel
  if(WheelPos < 85) {
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if(WheelPos < 170) {
   WheelPos -= 85;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
   WheelPos -= 170;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}

//============================================Helpers===============================================

word wordMap(word x, word in_min, word in_max, word out_min, word out_max)//word is an unsigned int. Is this faster than longs? maybe
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

void setHSV(int led, unsigned int hue, byte sat, byte val)            //Set led by hue, saturation, value
{
        unsigned char r,g,b;
        unsigned int H_accent = hue/60;
        unsigned int bottom = ((255 - sat) * val)>>8;
        unsigned int top = val;
        unsigned char rising  = ((top-bottom)  *(hue%60   )  )  /  60  +  bottom;
        unsigned char falling = ((top-bottom)  *(60-hue%60)  )  /  60  +  bottom;

        switch(H_accent) {
        case 0:
                r = top;
                g = rising;
                b = bottom;
                break;

        case 1:
                r = falling;
                g = top;
                b = bottom;
                break;

        case 2:
                r = bottom;
                g = top;
                b = rising;
                break;

        case 3:
                r = bottom;
                g = falling;
                b = top;
                break;

        case 4:
                r = rising;
                g = bottom;
                b = top;
                break;

        case 5:
                r = top;
                g = bottom;
                b = falling;
                break;
        }
        strip.setPixelColor(led, r, g, b);
}

void setAllHSV(unsigned int  h, byte  s, byte  v)        //Set all leds to one HSV
{
  for (int i = 0; i< ledCount;i++)
  {
    setHSV(i, h, s, v);
  }
}

//---FIND ADJACENT INDEX CLOCKWISE
int adjacent_cw(int i) {
  int r;
  if (i < ledCount - 1) {r = i + 1;}
  else {r = 0;}
  return r;
}

//---FIND ADJACENT INDEX COUNTER-CLOCKWISE
int adjacent_ccw(int i) {
  int r;
  if (i > 0) {r = i - 1;}
  else {r = ledCount - 1;}
  return r;
}

//---FIND INDEX OF HORIZONAL OPPOSITE LED
int horizontal_index(int i) {
  //-ONLY WORKS WITH INDEX < TOPINDEX
  if (i == BOTTOM_INDEX) {return BOTTOM_INDEX;}
  if (i == TOP_INDEX && EVENODD == 1) {return TOP_INDEX + 1;}
  if (i == TOP_INDEX && EVENODD == 0) {return TOP_INDEX;}
  return ledCount - i;  
}