byte iR1A;
byte iR2A;
byte iR3A;
byte iG1A;
byte iG2A;
byte iG3A;
byte iB1A;
byte iB2A;
byte iB3A;
int R1A;
int R2A;
int R3A;
int G1A;
int G2A;
int G3A;
int B1A;
int B2A;
int B3A;
int RpinA = 3;
int GpinA = 5;
int BpinA = 6;
char val;
int sped;
int speeder;
boolean R1big;
boolean R2big;
boolean R3big;
boolean G1big;
boolean G2big;
boolean G3big;
boolean B1big;
boolean B2big;
boolean B3big;
int Rprint1;
int Rprint2;
int Rprint3;
int Gprint1;
int Gprint2;
int Gprint3;
int Bprint1;
int Bprint2;
int Bprint3;
int inByte = 0;
int serialCount = 0;
byte readArray[10] = {iR1A, iG1A, iB1A, iR2A, iG2A, iB2A, iR3A, iG3A, iB3A, sped};

void setup(){
  Serial.begin(9600);
  pinMode(RpinA, OUTPUT);
  pinMode(GpinA, OUTPUT);
  pinMode(BpinA, OUTPUT);
}

void loop(){
  //do this stuff repeatedly
  readstuff(); //look to see if anything is being written
  cyclethrough(); //cycle through colors
}

/*
void readstuff(){
  //wireless read
  if (Serial.available() > 0) {
    //val = Serial.read();
    //while (val = 'G') {val = Serial.read();}

    //while (Serial.available() < 10) {}
    //val = Serial.read();
    iR1A = Serial.read();
    iG1A = Serial.read();
    iB1A = Serial.read();
    iR2A = Serial.read();
    iG2A = Serial.read();
    iB2A = Serial.read();
    iR3A = Serial.read();
    iG3A = Serial.read();
    iB3A = Serial.read();
    sped = Serial.read();
  }
  biggen();
  speeder = sped*50;
}
*/

void readstuff() {

  while(Serial.available() <= 0) {
    Serial.print('A');
      delay(1000);
    }

  while(Serial.available() > 0) {

    inByte = Serial.read();
    readArray[serialCount] = inByte;
    serialCount++;

	if (serialCount > 9) { //may be sufficient to have this as serialCount > 0
	  iR1A = readArray[0];
	  iG1A = readArray[1];
	  iB1A = readArray[2];
	  iR2A = readArray[3];
	  iG2A = readArray[4];
	  iB2A = readArray[5];
	  iR3A = readArray[6];
	  iG3A = readArray[7];
	  iB3A = readArray[8];
	  sped = readArray[9];
		}
	}

  biggen();
  speeder = sped*50;

}

void biggen(){
  //convert bytes to ints
  R1A = int(iR1A);
  R2A = int(iR2A);
  R3A = int(iR3A);
  G1A = int(iG1A);
  G2A = int(iG2A);
  G3A = int(iG3A);
  B1A = int(iB1A);
  B2A = int(iB2A);
  B3A = int(iB3A);
  //compute differences between values
  if (R1A >= R2A) {
    R1big == true;
  } else {R1big == false;}
  if (R2A >= R3A) {
    R2big == true;
  } else {R2big == false;}
  if (R3A >= R1A) {
    R3big == true;
  } else {R3big == false;}
  if (G1A >= G2A) {
    G1big == true;
  } else {G1big == false;}
  if (G2A >= G3A) {
    G2big == true;
  } else {G2big == false;}
  if (G3A >= G1A) {
    G3big == true;
  } else {G3big == false;}
  if (B1A >= B2A) {
    B1big == true;
  } else {B1big == false;}
  if (B2A >= B3A) {
    B2big == true;
  } else {B2big == false;}
  if (B3A >= B1A) {
    B3big == true;
  } else {B3big == false;}
}

void cyclethrough(){
  //cycling function, conditionals to determine which way to go: up or down
  if (R1big == true) {
    Rprint1 = R1A;
    for(int Rprint1; Rprint1 >= R2A; Rprint1--){
      analogWrite(RpinA, Rprint1);
      delay(speeder);
    }
  }
  if (R1big == false) {
    Rprint1 = R1A;
    for(int Rprint1; Rprint1 <= R2A; Rprint1++){
      analogWrite(RpinA, Rprint1);
      delay(speeder);
    }
  }
  if (G1big == true) {
    Gprint1 = G1A;
    for(int Gprint1; Gprint1 >= G2A; Gprint1--){
      analogWrite(GpinA, Gprint1);
      delay(speeder);
    }
  }
  if (G1big == false) {
    Gprint1 = G1A;
    for(int Gprint1; Gprint1 <= G2A; Gprint1++){
      analogWrite(GpinA, Gprint1);
      delay(speeder);
    }
  }
  if (B1big == true) {
    Bprint1 = B1A;
    for(int Bprint1; Bprint1 <= B2A; Bprint1--){
      analogWrite(BpinA, Bprint1);
      delay(speeder);
    }
  }
  if (B1big == false) {
    Bprint1 = B1A;
    for(int Bprint1; Bprint1 >= B2A; Bprint1++){
      analogWrite(BpinA, Bprint1);
    }
  }
  if (R2big == true) {
    Rprint2 = R2A;
    for(int Rprint2; Rprint2 <= R3A; Rprint2--){
      analogWrite(RpinA, Rprint2);
      delay(speeder);
    }
  }
  if (R2big == false) {
    Rprint2 = R2A;
    for(int Rprint2; Rprint2 >= R3A; Rprint2++){
      analogWrite(RpinA, Rprint2);
      delay(speeder);
    }
  }
  if (G2big == true) {
    Gprint2 = G2A;
    for(int Gprint2; Gprint2 <= G3A; Gprint2--){
      analogWrite(GpinA, Gprint2);
      delay(speeder);
    }
  }
  if (G2big == false) {
    Gprint2 = G2A;
    for(int Gprint2; Gprint2 >= G3A; Gprint2++){
      analogWrite(GpinA, Gprint2);
      delay(speeder);
    }
  }
  if (B2big == true) {
    Bprint2 = B2A;
    for(int Bprint2; Bprint2 <= B3A; Bprint2--){
      analogWrite(BpinA, Bprint2);
      delay(speeder);
    }
  }
  if (B2big == false) {
    Bprint2 = B2A;
    for(int Bprint2; Bprint2 >= B3A; Bprint2++){
      analogWrite(BpinA, Bprint2);
      delay(speeder);
    }
  }
  if (R3big == true) {
    Rprint3 = R3A;
    for(int Rprint3; Rprint3 >= R1A; Rprint3--){
      analogWrite(RpinA, Rprint3);
      delay(speeder);
    }
  }
  if (R3big == false) {
    Rprint3 = R3A;
    for(int Rprint3; Rprint3 <= R1A; Rprint3++){
      analogWrite(RpinA, Rprint3);
      delay(speeder);
    }
  }
  if (G3big == true) {
    Gprint3 = G3A;
    for(int Gprint3; Gprint3 >= G1A; Gprint3--){
      analogWrite(GpinA, Gprint3);
      delay(speeder);
    }
  }
  if (G3big == false) {
    Gprint3 = G3A;
    for(int Gprint3; Gprint3 <= G1A; Gprint3++){
      analogWrite(GpinA, Gprint3);
      delay(speeder);
    }
  }
  if(B3big == true) {
    Bprint3 = B3A;
    for(int Bprint3; Bprint3 >= B1A; Bprint3--){
      analogWrite(BpinA, Bprint3);
      delay(speeder);
    }
  }
  if(B3big == false) {
    Bprint3 = B3A;
    for(int Bprint3; Bprint3 <= B1A; Bprint3++){
      analogWrite(BpinA, Bprint3);
      delay(speeder);
    }
  }
}