EEPROM

//Code written by Ryan Chan; it is pretty inefficient, but gets the job done, I challenge you to make it more efficient!
 
int timeDelays[] = {0,0,0,0,0}; //Input delays here (in milliseconds)

#include <EEPROM.h>
#include <Servo.h>
  
Servo servo1; //Servos
Servo servo2;
Servo servo3;
 
const int LED1 = 2; //LEDs
const int LED2 = 3;
const int LED3 = 4;
const int LED4 = 7;
const int LED5 = 8;
 
const int button1 = 12; //Buttons
const int button2 = 13;
const int pauseButton = 10;
const int loadValuesButton = 0;
const int saveButton = 1;
 
int button1Presses = 0; //Button values
int saveButtonPresses = 0;
int loadButtonPresses = 0;
 
boolean runValues = false;
boolean allPositionsSaved = false;
 
const int pot1 = A0; //Potentimeters
const int pot2 = A1;
const int pot3 = A2;
 
int pot1Val; //Potentimeter values
int pot2Val;
int pot3Val;
int pot1Angle;
int pot2Angle;
int pot3Angle;
 
int servo1PosSaves[] = {1,1,1,1,1}; //position saves
int servo2PosSaves[] = {1,1,1,1,1};
int servo3PosSaves[] = {1,1,1,1,1};
 
void setup() {
  servo1.attach(5); // Set up everything and will run once; attach servos and define the pin modes
  servo2.attach(6);
  servo3.attach(9);
 
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(button1, INPUT);
  pinMode(button2, INPUT);
  pinMode(pauseButton, INPUT);
  pinMode(saveButton, INPUT);
  pinMode(loadValuesButton, INPUT);
 
  Serial.begin(9600);
}
 
void loop() {
  // put your main code here, to run repeatedly:
   
  pot1Val = analogRead(pot1); // This will read the values from the potentimeters and store it...
  pot1Angle = map(pot1Val, 0, 1023, 0, 179); // ... and this will map the values from the potentiometers to values the servos can use and store it for later use
  pot2Val = analogRead(pot2);
  pot2Angle = map(pot2Val, 0, 1023, 0, 179);
  pot3Val = analogRead(pot3);
  pot3Angle = map(pot3Val, 0, 1023, 0, 179);
 
  if(!allPositionsSaved){
    servo1.write(pot1Angle); // These will make the servos move to the mapped angles
    servo2.write(pot2Angle);
    servo3.write(pot3Angle);
  }
 
  if(digitalRead(button1) == HIGH){ // This will check how many times button1 is pressed and save the positions to an array depending on how many times it is pressed; switch/case works like an if statement
    button1Presses++;
    switch(button1Presses){
      case 1:
        servo1PosSaves[0] = pot1Angle;
        servo2PosSaves[0] = pot2Angle;
        servo3PosSaves[0] = pot3Angle;
        digitalWrite(LED1, HIGH);
        Serial.println("Pos 1 Saved");
        break;
      case 2:
         servo1PosSaves[1] = pot1Angle;
         servo2PosSaves[1] = pot2Angle;
         servo3PosSaves[1] = pot3Angle;
         digitalWrite(LED2, HIGH);
         Serial.println("Pos 2 Saved");
         break;
      case 3:
         servo1PosSaves[2] = pot1Angle;
         servo2PosSaves[2] = pot2Angle;
         servo3PosSaves[2] = pot3Angle;
         digitalWrite(LED3, HIGH);
         Serial.println("Pos 3 Saved");
         break;
       case 4:
         servo1PosSaves[3] = pot1Angle;
         servo2PosSaves[3] = pot2Angle;
         servo3PosSaves[3] = pot3Angle;
         digitalWrite(LED4, HIGH);
         Serial.println("Pos 4 Saved");
         break;
       case 5:
         servo1PosSaves[4] = pot1Angle;
         servo2PosSaves[4] = pot2Angle;
         servo3PosSaves[4] = pot3Angle;
         digitalWrite(LED5, HIGH);
         Serial.println("Pos 5 Saved");
         break;
    }
  }

  if(digitalRead(saveButton) == HIGH){
    saveButtonPresses++;
    delay(750);
  }

  switch(saveButtonPresses){
    case 1:
      //servo1PosSaves
      EEPROM.write(0, servo1PosSaves[0]);
      EEPROM.write(1, servo1PosSaves[1]);
      EEPROM.write(2, servo1PosSaves[2]);
      EEPROM.write(3, servo1PosSaves[3]);
      EEPROM.write(4, servo1PosSaves[4]);
      //servo2PosSaves
      EEPROM.write(5, servo2PosSaves[0]);
      EEPROM.write(6, servo2PosSaves[1]);
      EEPROM.write(7, servo2PosSaves[2]);
      EEPROM.write(8, servo2PosSaves[3]);
      EEPROM.write(9, servo2PosSaves[4]);
      //servo3PosSaves
      EEPROM.write(10, servo3PosSaves[0]);
      EEPROM.write(11, servo3PosSaves[1]);
      EEPROM.write(12, servo3PosSaves[2]);
      EEPROM.write(13, servo3PosSaves[3]);
      EEPROM.write(14, servo3PosSaves[4]);
      Serial.println("EEPROM 1 saved");
      break;
    case 2: 
      EEPROM.write(15, servo1PosSaves[0]);
      EEPROM.write(16, servo1PosSaves[1]);
      EEPROM.write(17, servo1PosSaves[2]);
      EEPROM.write(18, servo1PosSaves[3]);
      EEPROM.write(19, servo1PosSaves[4]);
      //servo2PosSaves
      EEPROM.write(20, servo2PosSaves[0]);
      EEPROM.write(21, servo2PosSaves[1]);
      EEPROM.write(22, servo2PosSaves[2]);
      EEPROM.write(23, servo2PosSaves[3]);
      EEPROM.write(24, servo2PosSaves[4]);
      //servo3PosSaves
      EEPROM.write(25, servo3PosSaves[0]);
      EEPROM.write(26, servo3PosSaves[1]);
      EEPROM.write(27, servo3PosSaves[2]);
      EEPROM.write(28, servo3PosSaves[3]);
      EEPROM.write(29, servo3PosSaves[4]);
      Serial.println("EEPROM 2 saved");
      break;
    case 3: 
      EEPROM.write(30, servo1PosSaves[0]);
      EEPROM.write(31, servo1PosSaves[1]);
      EEPROM.write(32, servo1PosSaves[2]);
      EEPROM.write(33, servo1PosSaves[3]);
      EEPROM.write(34, servo1PosSaves[4]);
      //servo2PosSaves
      EEPROM.write(35, servo2PosSaves[0]);
      EEPROM.write(36, servo2PosSaves[1]);
      EEPROM.write(37, servo2PosSaves[2]);
      EEPROM.write(38, servo2PosSaves[3]);
      EEPROM.write(39, servo2PosSaves[4]);
      //servo3PosSaves
      EEPROM.write(40, servo3PosSaves[0]);
      EEPROM.write(41, servo3PosSaves[1]);
      EEPROM.write(42, servo3PosSaves[2]);
      EEPROM.write(43, servo3PosSaves[3]);
      EEPROM.write(44, servo3PosSaves[4]);
      Serial.println("EEPROM 3 saved");
      break;
    case 4:
      for (int i = 0 ; i < 45 ; i++) {
        EEPROM.write(i, 0);
      }
      saveButtonPresses = 0;
      Serial.println("EEPROM cleared");
      break;
  }

  if(digitalRead(loadValuesButton) == HIGH){
    loadButtonPresses++;
    delay(750);
  }

  switch(loadButtonPresses){
    case 1:
      //servo1PosSaves
      servo1PosSaves[0] = EEPROM.read(0);
      servo1PosSaves[1] = EEPROM.read(1);
      servo1PosSaves[2] = EEPROM.read(2);
      servo1PosSaves[3] = EEPROM.read(3);
      servo1PosSaves[4] = EEPROM.read(4);
      //servo2PosSaves
      servo2PosSaves[0] = EEPROM.read(5);
      servo2PosSaves[1] = EEPROM.read(6);
      servo2PosSaves[2] = EEPROM.read(7);
      servo2PosSaves[3] = EEPROM.read(8);
      servo2PosSaves[4] = EEPROM.read(9);
      //Servo3PosSaves
      servo3PosSaves[0] = EEPROM.read(10);
      servo3PosSaves[1] = EEPROM.read(11);
      servo3PosSaves[2] = EEPROM.read(12);
      servo3PosSaves[3] = EEPROM.read(13);
      servo3PosSaves[4] = EEPROM.read(14);
      Serial.println("EEPROM save 1 loaded");
      break;
    case 2:
      servo1PosSaves[0] = EEPROM.read(15);
      servo1PosSaves[1] = EEPROM.read(16);
      servo1PosSaves[2] = EEPROM.read(17);
      servo1PosSaves[3] = EEPROM.read(18);
      servo1PosSaves[4] = EEPROM.read(19);
      //servo2PosSaves
      servo2PosSaves[0] = EEPROM.read(20);
      servo2PosSaves[1] = EEPROM.read(21);
      servo2PosSaves[2] = EEPROM.read(22);
      servo2PosSaves[3] = EEPROM.read(23);
      servo2PosSaves[4] = EEPROM.read(24);
      //Servo3PosSaves
      servo3PosSaves[0] = EEPROM.read(25);
      servo3PosSaves[1] = EEPROM.read(26);
      servo3PosSaves[2] = EEPROM.read(27);
      servo3PosSaves[3] = EEPROM.read(28);
      servo3PosSaves[4] = EEPROM.read(29);
      Serial.println("EEPROM save 2 loaded");
      break;
    case 3:
      servo1PosSaves[0] = EEPROM.read(30);
      servo1PosSaves[1] = EEPROM.read(31);
      servo1PosSaves[2] = EEPROM.read(32);
      servo1PosSaves[3] = EEPROM.read(33);
      servo1PosSaves[4] = EEPROM.read(34);
      //servo2PosSaves
      servo2PosSaves[0] = EEPROM.read(35);
      servo2PosSaves[1] = EEPROM.read(36);
      servo2PosSaves[2] = EEPROM.read(37);
      servo2PosSaves[3] = EEPROM.read(38);
      servo2PosSaves[4] = EEPROM.read(39);
      //Servo3PosSaves
      servo3PosSaves[0] = EEPROM.read(40);
      servo3PosSaves[1] = EEPROM.read(41);
      servo3PosSaves[2] = EEPROM.read(42);
      servo3PosSaves[3] = EEPROM.read(43);
      servo3PosSaves[4] = EEPROM.read(44);
      Serial.println("EEPROM save 3 loaded");
      break;
    case 4:
      loadButtonPresses = 0;
      break;
  }
 
  if(digitalRead(button2) == HIGH){ // Pretty self-explnatory here
    runValues = true;  
    allPositionsSaved = true;
  }
 
  if(digitalRead(pauseButton) == HIGH){ // if it is pressed for a second time
    runValues = true;
    delay(200);
  }
 
  if(runValues){ // if the boolean runValues is true, then the servos will rin though all their saved positions
    for(int i = 0; i < 5; i++){    
        if(digitalRead(pauseButton) == HIGH){ //the pause button
          runValues = false;
          delay(200);
          break;
        }
        delay(timeDelays[i]);
        servo1.write(servo1PosSaves[i]);
        servo2.write(servo2PosSaves[i]);
        servo3.write(servo3PosSaves[i]);
        Serial.println(" potentimeter Angles: ");
        Serial.println(servo1PosSaves[i]);
        Serial.println(servo2PosSaves[i]);
        Serial.println(servo3PosSaves[i]);
        delay(1050);
      }
  }
  delay(300);
}