//Tell the Arduino what libraries to include.
#include <TM1637.h>


//Tell the Arduino all pin numbers being used and the name that is assigned.
#define sunpot A0
#define carrierpot A2
#define ringpot A1
#define Sun 2
#define Carrier 3
#define Ring 4
#define SunDirection 5
#define CarrierDirection 6
#define RingDirection 7
#define sunOff 8
#define carrierOff 9
#define ringOff 10
#define Start 11
#define HoldSun 22
#define HoldCarrier 24
#define HoldRing 26
#define sunRPMsensor 52
#define carrierRPMsensor 50
#define ringRPMsensor 48


//each display needs an object name
TM1637 TM1, TM2, TM3;


//Tell the Arduino all global variables to be used in the program.
int value_sunpot = 0;
int value_carrierpot = 0;
int value_ringpot = 0;
int value_Start = 0;
float sundelay;
float carrierdelay;
float ringdelay;
unsigned long startTime = 0;
bool startPressed = false;
unsigned long previousMillis1 = 0;
unsigned long previousMillis2 = 0;
unsigned long previousMillis3 = 0;
unsigned long previousMillis4 = 0;
int sundelay_time = 0;
int carrierdelay_time = 0;
int ringdelay_time = 0;
unsigned long currentMillis = 0;
int sunRPMcount = 0;
int sunRPM = 0;
int carrierRPMcount = 0;
int carrierRPM = 0;
int ringRPMcount = 0;
int ringRPM = 0;
int accel = 100;
int accel2 = 0;
int accel3 = 0;


//This subprogram is the setup code, this runs once at the beginning.
void setup() {
  Serial.begin(19200);
  pinMode(Sun, OUTPUT);
  pinMode(SunDirection, OUTPUT);
  pinMode(Carrier, OUTPUT);
  pinMode(CarrierDirection, OUTPUT);
  pinMode(Ring, OUTPUT);
  pinMode(RingDirection, OUTPUT);
  pinMode(sunpot, INPUT);
  pinMode(carrierpot, INPUT);
  pinMode(ringpot, INPUT);
  pinMode(sunOff, OUTPUT);
  pinMode(carrierOff, OUTPUT);
  pinMode(ringOff, OUTPUT);
  pinMode(HoldSun, INPUT_PULLUP);
  pinMode(HoldCarrier, INPUT_PULLUP);
  pinMode(HoldRing, INPUT_PULLUP);
  pinMode(Start, INPUT_PULLUP);
  pinMode(sunRPMsensor, INPUT);
  TM1.begin(25, 23, 4);
  TM1.displayClear();
  TM2.begin(29, 27, 4);
  TM2.displayClear();
  TM3.begin(33, 31, 4);
  TM3.displayClear();

  digitalWrite(sunOff, HIGH);
  digitalWrite(carrierOff, LOW);
  digitalWrite(ringOff, LOW);
  digitalWrite(RingDirection, 1);
  digitalWrite(SunDirection, 1);
  digitalWrite(CarrierDirection, 1);
}


//This subprogram runs the Sun gear.
void runSun() {
//code to run speed of sun gear
   sundelay = map(analogRead(sunpot),0,1023,-10,10);
   if(sundelay != 0){
    digitalWrite(sunOff, LOW);
    sundelay_time = 10 / abs(sundelay);
   }
   else{
    digitalWrite(sunOff, HIGH);
   }
//direction of sun
       if(sundelay > 0){
      digitalWrite(SunDirection, 1);
    }
    else{
      digitalWrite(SunDirection, 0);
    }

        if (currentMillis - previousMillis1 >= sundelay_time){
      previousMillis1 = currentMillis;
      digitalWrite(Sun, HIGH);
      digitalWrite(Sun, LOW);
    }
  TM1.displayInt(sundelay);
}

//This subprogram runs the Carrier gear.
void runCarrier(){
//code to run speed
   carrierdelay = map(analogRead(carrierpot),0,1023,-10,10);
   if(carrierdelay != 0){
    digitalWrite(carrierOff, LOW);
    carrierdelay_time = 11 - abs(carrierdelay);
    TM2.displayInt(carrierRPM);
   }
   else{
    digitalWrite(carrierOff, HIGH);
    TM2.displayInt(0);
   }
//direction of carrier
    if(carrierdelay > 0){
      digitalWrite(CarrierDirection, 1);
    }
    else{
      digitalWrite(CarrierDirection, 0);
    }

        if (currentMillis - previousMillis2 >= carrierdelay_time){
      previousMillis2 = currentMillis;
      digitalWrite(Carrier, HIGH);
      digitalWrite(Carrier, LOW);
    }
}

//This subprogram runs the Ring gear.
void runRing(){
     ringdelay = map(analogRead(ringpot),0,1023,-10,10);
   if(ringdelay != 0){
    digitalWrite(ringOff, LOW);
    ringdelay_time = 10 / abs(ringdelay);
   }
   else{
    digitalWrite(ringOff, HIGH);
   }

        if(ringdelay > 0){
      digitalWrite(RingDirection, 1);
    }
    else{
      digitalWrite(RingDirection, 0);
    }

    if (currentMillis - previousMillis3 >= ringdelay_time){
      previousMillis3 = currentMillis;
      digitalWrite(Ring, HIGH);
      digitalWrite(Ring, LOW);
    }
 TM3.displayInt(ringdelay);
}


//This subprogram measures how fast the Sun gear is spinning using the sensor.
void sunSpeed() {
  int sunRPMsensorState = digitalRead(sunRPMsensor);
  int sunRPMsensorStateLast = 0;
  if (sunRPMsensorStateLast == HIGH && sunRPMsensorState == LOW){
    sunRPMcount++;
  }
  sunRPMsensorStateLast = sunRPMsensorState;
  if (currentMillis - previousMillis4 >= 1000){
    previousMillis4 = currentMillis;
    sunRPM = sunRPMcount * 0.15;
  }
}

//This subprogram measures how fast the Carrier gear is spinning using the sensor.
void carrierSpeed() {
  int carrierRPMsensorState = digitalRead(carrierRPMsensor);
  int carrierRPMsensorStateLast = 0;
  if (carrierRPMsensorStateLast == HIGH && carrierRPMsensorState == LOW){
    sunRPMcount++;
  }
  carrierRPMsensorStateLast = carrierRPMsensorState;
  if (currentMillis - previousMillis4 >= 1000){
    previousMillis4 = currentMillis;
    carrierRPM = carrierRPMcount * 0.15;
  }
}

//This subprogram measures how fast the Ring gear is spinning using the sensor.
void ringSpeed() {
  int ringRPMsensorStateLast = 0;
  int ringRPMsensorState = digitalRead(ringRPMsensor);
  if (ringRPMsensorStateLast == HIGH && ringRPMsensorState == LOW){
    ringRPMcount++;
  }
  ringRPMsensorStateLast = ringRPMsensorState;
  if (currentMillis - previousMillis4 >= 1000){
    previousMillis4 = currentMillis;
    ringRPM = ringRPMcount * 0.15;
  }
}


//This subprogram runs the motors in "Transmission" mode, simulating a hybrid car transmission.
void runTransmission(){
  //Stage 1, Acceleration using Ring Gear
  if (currentMillis - previousMillis3 >= accel && accel != 11 && accel != 10){
      previousMillis3 = currentMillis;
      digitalWrite(Ring, HIGH);
      digitalWrite(Ring, LOW);
      accel--;
  }
  if(accel == 11){
    digitalWrite(sunOff, LOW);
    digitalWrite(carrierOff, HIGH);
    accel--;
  }

  if(accel == 10){
    if (currentMillis - previousMillis3 >= accel){
      previousMillis3 = currentMillis;
      digitalWrite(Ring, HIGH);
      digitalWrite(Ring, LOW);
    }
    if (currentMillis - previousMillis1 >= accel){
      previousMillis1 = currentMillis;
      digitalWrite(Sun, HIGH);
      digitalWrite(Sun, LOW);
      accel2++;
    }
  }

  if(accel2 >= 1000){
    digitalWrite(carrierOff, LOW);
    digitalWrite(ringOff, HIGH);
    runSun();
    if (currentMillis - previousMillis2 >= 10){
      previousMillis2 = currentMillis;
      digitalWrite(Carrier, HIGH);
      digitalWrite(Carrier, LOW);
    }
  }
}


void loop() {
  //Tells the Arduino how much time has passed since being powered. Measured in milliseconds.
  currentMillis = millis();

  //Looks to see if the start button was pressed. Will run the program when it is.
  if(!startPressed){
    if(digitalRead(Start) == LOW){
      startPressed = true;
    }
  else{
    startPressed = false;
    }
  }

  //This is the main loop of the code, this runs all the subprograms.
  if(startPressed){
    //This state runs the Carrier and Ring gear, the Sun gear is driven.
    if(digitalRead(HoldSun) == LOW){
      digitalWrite(sunOff, HIGH);
      runCarrier();
      runRing();
      sunSpeed();
     }

    //This state runs the Sun and Ring gear, the Carrier gear is driven.
    else if(digitalRead(HoldCarrier) == LOW){
      digitalWrite(carrierOff, HIGH);
      runSun();
      runRing();
      carrierSpeed();
      }

      //This state runs the Sun and Carrier gear, the Ring gear is driven.
      else if(digitalRead(HoldRing) == LOW){
        digitalWrite(ringOff, HIGH);
        runSun();
        runCarrier();
        ringSpeed();
        }

        //This state runs the motors in "Transmission" mode.
        else{
         runTransmission();
        }
  }
}