// Number of Drives
#define DRIVES 3

// Constants for control pin parameters
char pinDir[DRIVES] = { 3, 6, A0 };      // Direction Pins
char pinStep[DRIVES] = { 4, 7, A1 };     // Step pins
char pinEnable[DRIVES] = { 8, 9, 10 };   // Audio Enable pins

// Drive Interface pins
#define P_INDEX 2      // Index Pulse Input Pin
#define P_WGATE 5      // Write Gate Enable Pin

// Flags used
#define EN_DELAY 8      // Delay between end of seek and enable
#define EN_OFF 100      // Note channel off

// Control pins
#define P_1 13         // Button 1 (Read All)
#define P_2 12         // Button 2 (Write All)
#define P_3 A2         // Button 3 (Write Track)

#define HOMERATE 6     // Step rate to home in milliseconds
#define STEPRATE 3     // Step rate in milliseconds

// MIDI Control signals
#define NOTEOFF 0x80
#define NOTEON 0x90

// Global registers
volatile char track[DRIVES];  // current track
volatile char seekTo[DRIVES]; // Seek to track
volatile char en[DRIVES];     // sound is enabled flag
volatile char readButton;
volatile char writeButton;
volatile char trackButton;

ISR(TIMER1_COMPA_vect) {
  char i;
  // Button Handler.
  // When a button is pressed, its register is set to
  // a 1, but only if the button is down. If the button
  // is then released, the flag is set to 2, which tells
  // the main program loop to perform the function.

  // If button is flaged, return with 2 in its register
  if(readButton == 1) readButton = 2;
  if(writeButton == 1) writeButton = 2;
  if(trackButton == 1) trackButton = 2;

  // If button is physically pushed, flag button.
  if(digitalRead(P_1) == LOW) readButton = 1;
  if(digitalRead(P_2) == LOW) writeButton = 1;
  if(digitalRead(P_3) == LOW) trackButton = 1;

  // Determine seek and sound enable for drives
  for(i=0;i<(DRIVES);i++) {
    if(track[i] > seekTo[i]) {
      digitalWrite(pinEnable[i],LOW);
      digitalWrite(pinDir[i],HIGH);          // Set Direction
      digitalWrite(pinStep[i],LOW);        // Pulse step
      digitalWrite(pinStep[i],HIGH);
      track[i]--;
    } 
    else if(track[i] < seekTo[i]) {
      digitalWrite(pinEnable[i],LOW);
      digitalWrite(pinDir[i],LOW);          // Set Direction
      digitalWrite(pinStep[i],LOW);        // Pulse step
      digitalWrite(pinStep[i],HIGH);
      track[i]++;
    } 
    else if(en[i] != EN_OFF) {          // if stopped and enabled
      if(en[i] == 0) 
        digitalWrite(pinEnable[i],HIGH);
      else
        en[i]--;
    } 
    else {
      digitalWrite(pinEnable[i],LOW);
    }
  }
}

void stepIn () {
  digitalWrite(pinDir[0],LOW);    // Set Direction
  digitalWrite(pinStep[0],LOW);        // Pulse step
  digitalWrite(pinStep[0],HIGH);
  delay(STEPRATE);
}

void stepOut () {
  digitalWrite(pinDir[0],HIGH);
  digitalWrite(pinStep[0],LOW);
  digitalWrite(pinStep[0],HIGH);
  delay(STEPRATE);
}

void waitIndex () {
  while (digitalRead(P_INDEX) == LOW);
  while (digitalRead(P_INDEX) == HIGH);
}

void homeDrive () {
  char i;
  digitalWrite(pinDir[0],HIGH);
  for(i=0;i<80;i++) {
    digitalWrite(pinStep[0],LOW);
    digitalWrite(pinStep[0],HIGH);
    delay(HOMERATE);
  }
  track[0] = 0;
  seekTo[0] = 0;
}

void writeTrack () {
  waitIndex();
  digitalWrite(P_WGATE,LOW);
  waitIndex();
  digitalWrite(P_WGATE,HIGH);
}

void readAll() {
  char i;
  TIMSK1 &= ~(1<<OCIE1A);
  homeDrive();
  for(i=0;i<(DRIVES);i++)
    digitalWrite(pinEnable[i], LOW);
  for (i=0; i<80; i++) {
    waitIndex();
    digitalWrite(pinEnable[0], LOW);
    stepIn();
    delay(25);
    digitalWrite(pinEnable[0],HIGH);
  }
  digitalWrite(pinEnable[0],LOW);
  homeDrive();
  TIMSK1 |= (1<<OCIE1A);
}

void writeAll() {
  char i;
  TIMSK1 &= ~(1<<OCIE1A);
  homeDrive();
  for (i=0; i<80; i++) {
    digitalWrite(P_WGATE,LOW);    // Write Enable
    waitIndex();
    delay(6);                     // Removes clicks in samples
    digitalWrite(P_WGATE,HIGH);   // Disable Write
    delay(1);
    stepIn();
  }
  homeDrive();
  TIMSK1 |= (1<<OCIE1A);
}

void setup() {
  char i,j;
  noInterrupts();           // Disable for safety
  
  digitalWrite(P_WGATE,HIGH); // Disable Write Gate before
  pinMode(P_WGATE,OUTPUT);    // setting the output mode
  
  pinMode(P_INDEX, INPUT);  // Index Pulse is input
  pinMode(P_1, INPUT);      // Push Button 1
  pinMode(P_2, INPUT);      // Push Button 2
  pinMode(P_3, INPUT);      // Push Button 3
  // Enable pullup resistors
  digitalWrite(P_INDEX,HIGH);
  digitalWrite(P_1,HIGH);
  digitalWrite(P_2,HIGH);
  digitalWrite(P_3,HIGH);

  pinMode(11,OUTPUT);
  TCCR2A = (1<<COM2A0)|(1<<WGM21);
  TCCR2B = (1<<CS20);
  OCR2A = 2;

  for(i=0;i<(DRIVES);i++) {
    pinMode(pinDir[i], OUTPUT);      // Set pins to output
    pinMode(pinStep[i], OUTPUT);
    pinMode(pinEnable[i], OUTPUT);
    digitalWrite(pinDir[i],HIGH);     // Set default direction
    digitalWrite(pinStep[i], HIGH);   // No Step
    digitalWrite(pinEnable[i], LOW);  // Disable audio
    seekTo[i] = 0;
    track[i] = 0;
    en[i] = EN_OFF;
  }

  // Set up MIDI serial interface
  Serial.begin(31250);

  // Set up Timer1 
  TCCR1A = 0;
  // Prescaler of 64, CTC Mode
  TCCR1B = (1<<CS10)|(1<<CS11)|(1<<WGM12);

  // 3 milliseconds 
  OCR1A = 750;

  interrupts();     // enable all interrupts (used for delay)
  // Home the drives outside the interrupt cycle
  for(i=0;i<90;i++) {
    for(j=0;j<(DRIVES);j++) {
      digitalWrite(pinStep[j],LOW);
      digitalWrite(pinStep[j],HIGH);
    }
    delay(HOMERATE);
  }

  // Enable timer compare interrupt
  TIMSK1 |= (1<<OCIE1A);
}

void loop() {
  unsigned char n, state, v, drive;
  unsigned char curr[DRIVES];      // current note on drive
  Serial.flush();
  for (;;) {
    while (Serial.available() == 0) {
      if (trackButton == 2) {
        writeTrack();
        trackButton = 0;
      }
      if (readButton == 2) {
        readAll();
        readButton = 0;
      }
      if (writeButton == 2) {
        writeAll();
        writeButton = 0;
      }
    }
    n = Serial.read();
    switch (n & 0x80) {
    case 0:
      drive = state & 0x0F;
      if(drive < DRIVES) {
        switch (state&0xF0) {
        case NOTEON:
          v = Serial.read();
          if ((v!=0)&&(n<92)&&(n>36)) {
            seekTo[drive] = n-36;
            en[drive] = EN_DELAY;
            curr[drive] = n;
          } 
          else if ((curr[drive] == n)&&(v==0)) {
            en[drive] = EN_OFF;
          }
          break;
        case NOTEOFF:
          v = Serial.read();
          if (curr[drive] == n)
            en[drive] = EN_OFF;
          break;
        }
      }
    case 0x80:
      state = n;
      break;
    }
  }
}