/*
Window Control Sketch - ATTiny84 
V1.0
This sketch has two purposes and is designed for use in a car.  The first
 purpose of this sketch is to fade a set of LEDs on when the car door is opened,
 then fade them back off when the car door is closed.  The second purpose of
 this sketch is to make a push button that when pressed, the door window will
 roll down when the door is opened, then roll back up when the door is clossed.
 Sin fading is defualt, linear fading is commented out.*/
// Define the pins the potentiometers are on
const int potPin0 = A0;
const int potPin1 = A1;

// Define the pins the pushbutton and door switches are on
const int buttonPin[] = {
  10, 9, 5};
// Define the pins that will ultimately control the window rolling up or down
const int windowPin[] = {
  7, 8};
// Define the pin the LEDs to fade are on
const int ledPin = 6;

// Sin function incriment amount
const float sinDelay = 0.0007;


// Linear Fade Variables
/*
// Define the amount of time the fade delay will be
const int fadeDelay = 15;
// Define the brightness increase interval
const int fadeAmount = 3;
*/


// Define the delay for button debounce
const int debounceDelay = 25;
// Define the amount of time the windows will spend rolling up and down.
//rollUpDelay will be longer to ensure window rolls all the way up.
int rollUpDelay = 3000;
int rollDownDelay = 2000;

//Variables that will change

// Variable to track the current state of the push button, in an array the size
//of buttonPin.
boolean currentButtonVal[sizeof(buttonPin)/sizeof(buttonPin[0])];
// Initialize variables to define and store the debounced switch values. doorSwitch
//is in an array the size of buttonPin
byte doorSwitch[2];
byte windowButton;
// Define the inital brightness of the LED. Starts off, or 0
int brightness = 0;
// Define the inital "previous time" variable for comparison with millis().
//Will start at 0 and be redifned every time fadeDelay has passed.
unsigned long previousTime = 0;
// Define the inital comparison time for the debounce function. Must be in array
//the size of buttonPin[].
static unsigned long lastDebounceTime[sizeof(buttonPin)/sizeof(buttonPin[0])];
// Create a local variable to be returned as the button state.  Must be in array
//the size of buttonPin[].
static byte buttonState[sizeof(buttonPin)/sizeof(buttonPin[0])];
// Initialize a variable that is set to millis() every time a button state is
//toggled. In an array the size of buttonPin[], and is unique to each button.
unsigned long toggleTime[sizeof(buttonPin)/sizeof(buttonPin[0])];
// Define the inital state for a button toggle. This value will be reversed
//when a button is pressed. In an array the size of buttonPin[], and is unique
//to each button.
boolean buttonToggle[sizeof(buttonPin)/sizeof(buttonPin[0])] = {};
// Initialize a variable to track if the rollWindow function should be active
boolean rollWindowToggle;
// Initialize a variable to detect if the rollWindow button should finish
boolean continueFunction;

void setup () {
  for (int i = 0; i < sizeof(buttonPin)/sizeof(buttonPin[0]); i++) {
    pinMode (buttonPin[i], INPUT_PULLUP);
  }
  pinMode (potPin0, INPUT);
  for (int i = 0; i < sizeof(windowPin)/sizeof(windowPin[0]); i++) {
  pinMode (windowPin[i], OUTPUT);
  }
  pinMode (ledPin, OUTPUT);
}


void loop () {

  // Define variables to debounce and keep track of the different switches
  doorSwitch[0] = debounce(0); // buttonPin[0]
  doorSwitch[1] = debounce(1); // buttonPin[1]
  windowButton = debounce(2); // buttonPin[2]

  // Create a variable to store the millis() value this time through the loop
  unsigned long currentTime = millis();

  // Take a reading from pot and store the value in a local variable
  int potValue0 = analogRead (potPin0);
  int potValue1 = analogRead (potPin1);

  // Map potValue to be within the desired second range, and assing it to
  //rollUpDelay and rollDownDelay
  rollUpDelay = map(potValue0, 0, 1023, 250, 2500);
  rollDownDelay = map(potValue1, 0, 1023, 250, 2500);


  //Variables for sin fading
  // Initial input value, 4.712 is the bottom of a sine wave
  static float input = 4.712;
  // Define the variable "sinOut" as floating
  float sinOut;

  // If either car door is open, then fade the LEDs.  If both car doors are
  //closed, then fade the LEDs off.
  if (doorSwitch[0] == LOW || doorSwitch[1] == LOW) {

    // Sin fade
    // Increase the input number by the defined amount
    input = input + sinDelay;
    // If the input has reached the "top" of the wave, reset it to the top
    if (input >= 7.853) input = 7.853;
    // Create the number between 0 and 255 for brightness
    sinOut = sin(input) * 127.5 + 127.5;
    // Write the brightness to the LED
    analogWrite (ledPin, sinOut);


    // Linear Fade
    /*
    if (currentTime - previousTime > fadeDelay) {
      previousTime = currentTime;
      brightness = brightness + fadeAmount;
      // Limit the fade amount from going above 255
      brightness = min(brightness, 255);
      analogWrite (ledPin, brightness);
    }
    */

  }
  else {
    // Sin fade
    // Increase the input number by the defined amount
    input = input - sinDelay;
    // If the input has reached the "top" of the wave, reset it to the top
    if (input <= 4.712) input = 4.712;
    // Create the number between 0 and 255 for brightness
    sinOut = sin(input) * 127.5 + 127.5;
    // Write the brightness to the LED
    analogWrite (ledPin, sinOut);


    // Linear Fade
    /*
    if (currentTime - previousTime > fadeDelay) {
      previousTime = currentTime;
      brightness = brightness - fadeAmount;
      // Limit the fade amount from going bellow 0
      brightness = max(brightness, 0);
      analogWrite (ledPin, brightness);
    }
    */

  }

  // If windowButton has been toggled to true (on) and the door switch is HIGH,
  //then make rollWindowToggle true. This Allows the rollWindow function to
  //begin. If buttonToggle is not true (on), then make rollWindowToggle false.
  if (buttonToggle[2] == true) { //Start function when buttonToggle is true
    if (doorSwitch[0] == LOW) { //If the door is open
      rollWindowToggle = true; //Let the rollWindow function execute
    }
  }
  else rollWindowToggle = false;

  // Test to see if rollWindowToggle was toggled on while the door was open,
  //if it was, then reset toggleTime so the window will still roll the correct
  //amount of time. continueFunction must not equal true so toggleTime does not
  //continuously reset if rollWindowToggle gets toggled while the function is
  //in progress.
  if (!rollWindowToggle && doorSwitch[0] == LOW && !continueFunction) {
    toggleTime[0] = millis();
  }

  // Iniate rollWindow function if either requirment is meant. continueFunction
  //tracks if the function should continue, even if rollWindowToggle is
  //toggled to false.
  if (rollWindowToggle || continueFunction) {
    // Iniate rollWindow function, doorSwitch and toggleTime indicate which
    //switch will activate the function. currentTime passes the variable assigned
    //to millis().
    rollWindow(0, currentTime);
  }
}


void rollWindow (int thisSwitch, unsigned long currentTime) {
  // Variable to check if the window is Allowed to roll down
  static boolean downAllow = true;

  // Variable to keep the window rolling down until the desired time has passed
  static boolean continueDown = false;

  // Variable to check if the toggle time needs to be recorded
  static boolean checkTime = true;

  // If statements checks if door is open or closed and performs apropriate function

  // If the door is open
  if (doorSwitch[thisSwitch] == LOW || continueDown == true) {

    // Define the state of continueFunction to indicate that the function is
    //in progress and should continue until it is complete
    continueFunction = true;

    // Define startTime to compare against currentTime to see if rollDownDelay
    //has passed
    static unsigned long startTime;

    // Check to see if the window has just started rolling, and if so record
    //toggleTime
    if (checkTime == true) {
      startTime = toggleTime[thisSwitch];

      // Time has been recored, don't do it again until function restarts
      checkTime = false;
    }

    // If the rollDownDelay time has passed, stop rolling the window. If not,
    //roll the window down. Make windowPin[1] LOW to ensure the window will
    //not try to roll down and up at the same time.

    //If roll up time has passed:
    if (currentTime - startTime > rollDownDelay) {
      digitalWrite (windowPin[0], LOW); //Stop rolling the window down
      digitalWrite (windowPin[1], LOW); //Prevent window from rolling up
      downAllow = false; // Prevent window from rolling down until next time
      continueDown = false; // Time has passed, window has finished rolling down
    }
    else {
      digitalWrite (windowPin[1], LOW); //Make sure the window is not rolling up
      if (downAllow == true) {
        digitalWrite (windowPin[0], HIGH); //Make the window roll down

        // Define the state of continueDown to indicate that the window
        //should continue to roll down
        continueDown = true;
      }
    }
  }
  // If the door is closed:
  else {
    // If the rollUpDelay time has passed, stop rolling the window, reset
    //buttonToggle[2] to false, and make continueFunction false to indicate
    //the function is complete. If rollUpDelay time has not passed, then
    //roll the window up and make windowPin[0] LOW to ensure the window will
    //not try to roll up and down at the same time.
    if (currentTime - toggleTime[thisSwitch] > rollUpDelay + 1500) { // + 1500 for delay in else
      digitalWrite (windowPin[1], LOW);
      buttonToggle[2] = false;
      continueFunction = false;
      // Function is done. Reset downAllow and checkTime
      downAllow = true;
      checkTime = true;
    }
    else {
      digitalWrite (windowPin[0], LOW);
      // Wait 500 mS to ensure door is closed before rolling window
      if (currentTime - toggleTime[thisSwitch] >= 1500) {
      digitalWrite (windowPin[1], HIGH);
      }
    }
  }
}


// Create a debounce function to debounce the switches, start the toggleTime
//timer, and toggle the buttonToggle variable. Return the value current.
byte debounce(int buttonNumber) {


  // Take a reading of the switch pin and store it in a local variable.
  byte current = digitalRead(buttonPin[buttonNumber]);


  // If the reading does not equal the current recorded state of the button,
  //wait the debounceDelay, then take another reading of the currenet value and
  //begin the toggle timer.  If the state of the switch is high, then toggle
  //buttonToggle.
  if (current != currentButtonVal[buttonNumber]) {
    lastDebounceTime[buttonNumber] = millis();
  }
  if (millis() - lastDebounceTime[buttonNumber] > debounceDelay) {
    if (current != buttonState[buttonNumber]) {
      buttonState[buttonNumber] = current;
      toggleTime[buttonNumber] = millis();
      if (buttonState[buttonNumber] == LOW) {
      buttonToggle[buttonNumber] = !buttonToggle[buttonNumber];
      }
    }
  }
  // Record the curent button value and return buttonState
  currentButtonVal[buttonNumber] = current;
  return buttonState[buttonNumber];
}


// Old, broken debounce function.

/*
// Create a debounce function to debounce the switches, start the toggleTime
//timer, and toggle the buttonToggle variable. Return the value current.
byte debounce(int thisButton) {
  // Take a reading of the switch pin and store it in a local variable.
  byte current = digitalRead(buttonPin[thisButton]);
  // If the reading does not equal the current recorded state of the button,
  //wait the debounceDelay, then take another reading of the currenet value and
  //begin the toggle timer.  If the state of the switch is high, then toggle
  //buttonToggle.
  if (currentButtonVal[thisButton] != current) {
    if (millis() - lastDebounceTime[buttonNumber] > debounceDelay) {
      current = digitalRead(buttonPin[thisButton]);
      toggleTime[thisButton] = millis();
      if (current == HIGH) {
        buttonToggle[thisButton] = !buttonToggle[thisButton];
      }
    }
  }
  // Record the curent button value and return current
  currentButtonVal[thisButton] = current;
  return current;
}
*/

void Down_Process()
{
  static unsigned long RH_StartTime;                       // Create a variable to hold the RH window's start time
  static unsigned long LH_StartTime;                       // Create a variable to hold the LH window's start time

  // RH Window:
  if (DoorLockState == 1 && RH_DoorHandleState == 1 && RH_WindowUpState == 1)  // If the Doors are Un-Locked, the window is up, and the handle is pulled
    {
      RH_StartTime = millis();                             // Set startTime to the ammmount of time elapsed (since boot)
      digitalWrite(RH_WindowDownOutput, HIGH);               // Activate the RH Window Down Output Relay
      RH_Door_Up_Activation = 1;                             // RH Door Activation Window Up Register - To allow Up on only after a triggered down
    }
  else if (millis() - RH_StartTime >= RH_WindowTimer && RH_WindowUpState == 0 && RH_Door_Up_Activation == 1) // If the time since RH_StartTime was set is greater than roll time and the window is not up:
    {
      digitalWrite(RH_WindowDownOutput, LOW);                // De-Activate the RH Window Down Output Relay
    }

  // LH Window
  if (DoorLockState == 1 && LH_DoorHandleState == 1 && LH_WindowUpState == 1)
    {
      LH_StartTime = millis();
      digitalWrite(LH_WindowDownOutput, HIGH);               // Activate the LH Window Down Output Relay
      LH_Door_Up_Activation = 1;                             // RH Door Activation Window Up Register - To allow Up on only after a triggered down
    }
  else if (millis() - LH_StartTime >= LH_WindowTimer && LH_WindowUpState == 0 && LH_Door_Up_Activation == 1) // If the time elapsed since RH_StartTime was set is greater than your rolling time:
    {
      digitalWrite(LH_WindowDownOutput, LOW);                // De-Activate the RH Window Down Output Relay
    }
}

void Up_Process()
{
  // RH Window:
  if (RH_WindowUpState == 0 && RH_Door_Up_Activation == 1 && DoorOpenState == 0)    // If the window is down, RH_Door_Up_Activation is active, and the door is clossed.
    {
      digitalWrite(LH_WindowDownOutput, LOW);                                       // De-Activate the RH Window Down Output Relay (in case it's active)
      digitalWrite(RH_WindowUpOutput, HIGH);                                          // Activate the RH Window Up Output Relay
    }
  else if (RH_WindowUpState == 1 && RH_Door_Up_Activation == 1)                     // If the RH Window is in the UP Position & last activation was window down
        {
         RH_Door_Up_Activation = 0;                                                   // RH Door Activation Register as it was moved Up in this function previously - 0 is UP
         digitalWrite(RH_WindowUpOutput, LOW);                                        // De-Activate the RH Window Down Output Relay
        }

  // LH Window:
  if (LH_WindowUpState == 0 && LH_Door_Up_Activation == 1 && DoorOpenState == 0)    // If the window is down, LH_Door_Up_Activation is active, and the door is clossed.
    {
      digitalWrite(LH_WindowDownOutput, LOW);                                       // De-Activate the RH Window Down Output Relay (in case it's active)
      digitalWrite(LH_WindowUpOutput, HIGH);                                           // Activate the RH Window Down Output Relay
    }
  else if (LH_WindowUpState == 1 && RH_Door_Up_Activation == 1)                     // If the LH Window is in the UP Position & last activation was window down
    {
        LH_Door_Up_Activation = 0;                                                     // LH Door Activation Register as it was moved Up in this function previously - 0 is UP
        digitalWrite(LH_WindowUpOutput, LOW);                                          // De-Activate the LH Window Down Output Relay
    }
}

void Up_Process() 
{
  if (DoorLockState == 1 && DoorOpenState == 0)         // If the Doors are Un-Locked & Doors are closed & last activation was window down
    {
     RH_Door_Up_Process();                              // RH Door Up Process
     LH_Door_Up_Process();                              // LH Door Up Process
    } 
}

if (RH_WindowUpState == 0 && RH_Door_Up_Activation == 1)                        // RH Window is Not in the UP Position & Doors are closed & last activation was window down
          {   
           digitalWrite(RH_WindowUpOutput, HIGH);                                     // Activate the RH Window Down Output Relay
          } else if (RH_WindowUpState == 1 && RH_Door_Up_Activation == 1)             // If the RH Window is in the UP Position & last activation was window down
            {
             RH_Door_Up_Activation = 0;                                               // RH Door Activation Register as it was moved Up in this function previously - 0 is UP  
             digitalWrite(RH_WindowUpOutput, LOW);                                    // De-Activate the RH Window Down Output Relay                    
            }