This are all the codes we used for making this whole project possible. And all the code here are used in Ardiuno.

LED Control

#include <Adafruit_NeoPixel.h>

//LED
#define PinA 6  //WindowLight 4
#define PixelsA 24

#define PinC 7  //WindowLight 40
#define PixelsC 156

#define PinB 5  //StarLight
#define PixelsB 400 // total stars

int starsIncrement = 0;
int starsLighted = 0;

Adafruit_NeoPixel stripA = Adafruit_NeoPixel(PixelsA, PinA, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripC = Adafruit_NeoPixel(PixelsC, PinC, NEO_GRB + NEO_KHZ800);

Adafruit_NeoPixel stripB = Adafruit_NeoPixel(PixelsB, PinB, NEO_GRB + NEO_KHZ800);

//Sensor
#define trigPin 13
#define echoPin 11

//boolean windowTrigger = false;
boolean sensorStart = false;

//Star Light
float redStates[PixelsB];
float blueStates[PixelsB];
float greenStates[PixelsB];
float fadeRate = 0.96;

//Window Light
#define waitTime 2

// 4 LED
byte buttonPins[] = {
  22, 24, 26, 28, 30,
  32
  // 34, 36, 38, 40,
  // 42, 44
  //46, 48, 50,
  //52, 31, 33, 35, 37,
  //39, 41, 43, 45
};

boolean windowStatesT0[] = {
  1, 1, 1, 1, 1,
  1, 1
  //, 1, 1, 1,
  //  1, 1
  //1, 1, 1,
  //1, 1, 1, 1, 1,
  //1, 1, 1, 1
};

boolean windowStatesT1[] = {
  1, 1, 1, 1, 1,
  1, 1
  //, 1, 1, 1,
  //1, 1,
  //1, 1, 1,
  //1, 1, 1, 1, 1,
  //1, 1, 1, 1
};

// 12 LED
byte buttonPins2[] = {
  //  22, 24, 26, 28, 30,
  //  32, 34, 36, 38, 40,
  //  42, 44
  46, 48, 50, 52, 31,
  33, 35, 37,//
  //39, 41, 43, 45
};

boolean windowStatesT2[] = {
  1, 1, 1, 1, 1,
  1, 1, 1
  //1, 1, 1, 1
  //1, 1, 1,
  //1, 1, 1, 1, 1,
  //1, 1, 1, 1
};

boolean windowStatesT3[] = {
  1, 1, 1, 1, 1,
  1, 1, 1
  //1, 1, 1, 1,
  //1, 1, 1,
  //1, 1, 1, 1, 1,
  //1, 1, 1, 1
};

void setup() {

  //Light A
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
 
  pinMode(PinA, OUTPUT);
  stripA.begin();
  stripA.show();

  pinMode(PinB, OUTPUT);
  stripB.begin();
  stripB.show();

  pinMode(PinC, OUTPUT);
  stripC.begin();
  stripC.show();

  starsLighted = 0;
  starsIncrement = int( PixelsB / sizeof(windowStatesT0) );

  //Window Buttons
  //4
  for ( int i = 0; i < sizeof(buttonPins); i++ ) {
    pinMode(buttonPins[i], OUTPUT);
    digitalWrite(buttonPins[i], HIGH);
  }

  //12
  for ( int i = 0; i < sizeof(buttonPins2); i++ ) {
    pinMode(buttonPins2[i], OUTPUT);
    digitalWrite(buttonPins2[i], HIGH);
  }

  Serial.begin (9600);
}

void loop() {

  sensorTrigger();

  if (starsLighted > 0) {
    starLight();
  }

  checkButtons();
  //  checkButtons2();

}

void(* resetFunc) (void) = 0;

Sensor Trigger

void sensorTrigger() {

  //setGateway(13);
  float duration, distance;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  //setGateway(14);
  duration = pulseIn(echoPin, HIGH, 1000);

  if (duration > 0) {
    distance = (duration / 2) * 0.0344;
  }
  else {
    distance = 999;
  }

  if (sensorStart == false) {
    if (distance <= 10) {
      for ( int i = 0; i < sizeof(windowStatesT0); i++ ) {
        //windowFadeIN(255, 127, 0, waitTime, i);
        windowFadeIN2(255, 127, 0, waitTime, i);
        sensorStart = true;
        Serial.println("Hello");
        //colorWipe(stripB.Color(127, 127, 127), 50); // Red
      }
    }
  }

  if (sensorStart == true) {
    if (distance >= 10) {
      //Serial.println("END");
      resetFunc();
      //sensorStart = false;
    }
  }

  delay(50);
}

Stars Light

void starLight() {

  constrain(starsLighted, 0, PixelsB);

  int probabilityMargin = PixelsB / starsLighted;

  if (random(probabilityMargin) <= 1) {
    int i = random(0, starsLighted);
    redStates[i] = 50;
    greenStates[i] = 50;
    blueStates[i] = 50;
    int i2 = random(0, starsLighted);
    redStates[i2] = 50;
    greenStates[i2] = 50;
    blueStates[i2] = 50;
    int i3 = random(0, starsLighted);
    redStates[i3] = 50;
    greenStates[i3] = 50;
    blueStates[i3] = 50;
    int i4 = random(0, starsLighted);
    redStates[i4] = 50;
    greenStates[i4] = 50;
    blueStates[i4] = 50;
    int i5 = random(0, starsLighted);
    redStates[i5] = 50;
    greenStates[i5] = 50;
    blueStates[i5] = 50;
    int i6 = random(0, starsLighted);
    redStates[i6] = 50;
    greenStates[i6] = 50;
    blueStates[i6] = 50;
  }

  for (int l = 0; l < starsLighted; l++) {

    if (redStates[l] > 1 || greenStates[l] > 1 || blueStates[l] > 1) {

      stripB.setPixelColor(l, redStates[l], greenStates[l], blueStates[l]);

      if (redStates[l] > 1) {
        redStates[l] = redStates[l] * fadeRate;
        delay(1);
      } else {
        redStates[l] = 0;
      }

      if (greenStates[l] > 1) {
        greenStates[l] = greenStates[l] * fadeRate;
        delay(1);
      } else {
        greenStates[l] = 0;
      }

      if (blueStates[l] > 1) {
        blueStates[l] = blueStates[l] * fadeRate;
        delay(1);
      } else {
        blueStates[l] = 0;
      }

    } else {
      stripB.setPixelColor(l, 0, 0, 0);
    }

  }
  stripB.show();

  delay(5);
}

Window Fade In

void windowFadeIN(int red, int green, int blue, int wait, int thatFirstLED) {

  for (int b = 0; b < 255; b++) {
    int theFirstLED = thatFirstLED * 4;
    for (int pixID = theFirstLED ; pixID < theFirstLED + 4; pixID++) {
      //      stripA.setBrightness(100);
      //      stripA.setPixelColor(pixID, red * b / 255, green * b / 255, blue * b / 255);
      stripA.setBrightness(100);
      stripA.setPixelColor(pixID, red * b / 255, green * b / 255, blue * b / 255);
    }
    //    stripA.show();
    stripA.show();
    delayMicroseconds(100);
  }

}

void windowFadeIN2(int red, int green, int blue, int wait, int thatFirstLED) {

  for (int b = 0; b < 255; b++) {
    int theFirstLED = thatFirstLED * 40;
    for (int pixID = theFirstLED ; pixID < theFirstLED + 40; pixID++) {
      stripC.setBrightness(100);
      stripC.setPixelColor(pixID, red * b / 255, green * b / 255, blue * b / 255);
    }
    stripC.show();
    delayMicroseconds(100);
  }

}

Window Fade Out

void windowFadeOUT(int red, int green, int blue, int wait, int thatFirstLED) {

  for (int b = 255; b > 0; b--) {
    //    int theFirstLED = thatFirstLED * 4;
    int theFirstLED = thatFirstLED * (PixelsC / 6);

    //    for (int pixID = theFirstLED ; pixID < theFirstLED + 4; pixID++) {
    for (int pixID = theFirstLED ; pixID < theFirstLED + (PixelsC / 6); pixID++) {

      //      stripA.setBrightness(50);
      //      stripA.setPixelColor(pixID, red * b / 255, green * b / 255, blue * b / 255);
      stripC.setBrightness(50);
      stripC.setPixelColor(pixID, red * b / 255, green * b / 255, blue * b / 255);
    }
    //    stripA.show();
    stripC.show();
    delay(wait);
  }

}


void windowFadeOUT2(int red, int green, int blue, int wait, int thatFirstLED) {

  for (int b = 255; b > 0; b--) {
    int theFirstLED = thatFirstLED * 40;
    for (int pixID = theFirstLED ; pixID < theFirstLED + 40; pixID++) {
      stripC.setBrightness(50);
      stripC.setPixelColor(pixID, red * b / 255, green * b / 255, blue * b / 255);
    }
    stripC.show();
    delay(wait);
  }

}

Check Buttons

// 4 Window Light
void checkButtons() {
  for ( int i = 0; i < sizeof(buttonPins); i++ ) {
    //    Serial.print(i); Serial.print("\t");
    //    Serial.println(digitalRead(buttonPins[i]));
    if ( digitalRead(buttonPins[i]) == LOW ) {
      windowStatesT1[i] = 0;
      updateWindowLights();
    }
  }
}

void updateWindowLights() {
  for ( int i = 0; i < sizeof(windowStatesT0); i++ ) {
    if ( windowStatesT1[i] == 0 && windowStatesT0[i] != 0 ) {
      windowFadeOUT(255, 127, 0, waitTime, i);
      windowStatesT0[i] = 0;
      starsLighted += starsIncrement;
      if ( starsLighted >= PixelsB ) {
        starsLighted = PixelsB;
      }
    }
  }

}

// 12 Window Light
void checkButtons2() {
  for ( int i = 0; i < sizeof(buttonPins2); i++ ) {
    if ( digitalRead(buttonPins2[i]) == LOW ) {
      windowStatesT3[i] = 0;
      updateWindowLights2();
    }
  }
}

void updateWindowLights2() {
  for ( int i = 0; i < sizeof(windowStatesT2); i++ ) {
    if ( windowStatesT3[i] == 0 && windowStatesT2[i] != 0 ) {
      windowFadeOUT2(255, 127, 0, waitTime, i);
      windowStatesT2[i] = 0;
      starsLighted += starsIncrement;
      if ( starsLighted >= PixelsB ) {
        starsLighted = PixelsB;
      }
    }
  }

}

Testing

void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<stripB.numPixels(); i++) {
    stripB.setPixelColor(i, c);
    stripB.show();
    delay(wait);
  }
}