IEEE_488_V14

//Author  : G Clark
//Date    : 23 October 2019
//Version : 1.0
//Changes : Initial working version
//
//Author  : G Clark
//Date    : 26 October 2019
//Version : 1.1
//Changes : Changed the end of program from detecting three 0x00 to reading the size of the file
//          and pulling EOI down for the last byte. This will ensure any machine code after the
//          basic program is also sent.
//          Built in LED set to follow bit 7 of the loading index variable and the saving data
//          so it flashes as a program is saved or loaded.
//
//Author  : G Clark
//Date    : 26 October 2019
//Version : 1.2
//Changes : File names modified to not need padding characters. Still limited to 8 characters long
//          due to restriction of FAT32 file system
//
//Author  : G Clark
//Date    : 25 November 2019
//Version : 1.3
//Changes : Files are expected to be in folders labled 0 to 9. These simulate PET drive number (but lots of them)
//          The command LOAD"$",9 only gives the default (0) drive directory, to get the other drives use the
//          command LOAD"1:$",9 for example to get the filelist for drive 1. The directory command does not support
//          wildcards.
//
//Author  : G Clark
//Date    : 08 November 2022
//Version : 1.4
//Changes : File open moved to inside the loop on the directory send


const int DIO1 = 37;
const int DIO2 = 36;
const int DIO3 = 35;
const int DIO4 = 34;
const int DIO5 = 33;
const int DIO6 = 32;
const int DIO7 = 31;
const int DIO8 = 30;

const int EOI   = 28;
const int DAV   = 27;
const int NRFD  = 26;
const int NDAC  = 25;
const int IFC   = 24;
const int SQR   = 23;
const int ATN   = 22;
const int CS    = 53;

#include <SPI.h>
#include <SD.h>

//byte file[500];
// set up variables using the SD utility library functions:
Sd2Card   card;
SdVolume  volume;
SdFile    root;

    
void setup() {
File root;

  digitalWrite(NRFD,LOW);   // and pull low to signal the device isnt ready
  pinMode(NRFD,OUTPUT);     // First job, set NRFD as an output
  pinMode(DIO1,INPUT);      // setup the dataport as an input ready to accept commands
  pinMode(DIO2,INPUT);
  pinMode(DIO3,INPUT);
  pinMode(DIO4,INPUT);
  pinMode(DIO5,INPUT);
  pinMode(DIO6,INPUT);
  pinMode(DIO7,INPUT);
  pinMode(DIO8,INPUT);
  digitalWrite(EOI,LOW);
  pinMode(EOI,INPUT);
  pinMode(DAV,INPUT);
  pinMode(ATN,INPUT);
  digitalWrite(NDAC,LOW);   // Pull data not accepted low
  pinMode(NDAC,OUTPUT);
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
  Serial.println("CBM disk drive :");
  Serial.println("Checking SD card");
  if (!SD.begin(CS)) {
    Serial.println("SD card initialization failed!");
    while (1);
  }
  root = SD.open("/");
//  printDirectory(root, 0);

  delay(500);
  Serial.println("Startup complete");
  pinMode(NRFD,INPUT);      // Let NRFD go high to signal startup complete
}

void ATN_(){
byte addr,command;

// get listner address
  while(digitalRead(DAV) == HIGH){}
  pinMode(NRFD,OUTPUT);             // set line to indicate not ready for data
  addr = ~PINC ;
  Serial.print("Address ");
  Serial.println(addr);
  pinMode(NDAC,INPUT);              // allow to go high
  while(digitalRead(DAV) == LOW){}
  if (addr != 0x29) {               // if the ATN message is for another device
    pinMode(NRFD,INPUT);            // Set NRFD & NDAC to inputs to allow the addressed
    pinMode(NDAC,INPUT);            // device to control them
    return;                         // and exit to loop waiting for ATN
  }
  Serial.println("ATN seen");
  pinMode(NDAC,OUTPUT);
  pinMode(NRFD,INPUT);
    
// get command
  while(digitalRead(DAV) == HIGH){}
  pinMode(NRFD,OUTPUT);
//  delay(5);
  command = ~PINC;
  Serial.print("Command received = ");
  Serial.println(command,HEX);
  pinMode(NDAC,INPUT);
  while(digitalRead(DAV) == LOW){}
//  delay(5);
  pinMode(NDAC,OUTPUT);

  if (command == 0xF1) {Save();}
  if (command == 0xF0) {Load();}
  if (command == 0x6F) {Comm();}
  
  return;
}

void Comm(){
byte addr;
bool EOI_;
char command[15];
int index;
File file_;

    index = 0;
    EOI_ = HIGH;
    pinMode(NRFD,INPUT);
    while (EOI_ == HIGH){
      while(digitalRead(DAV) == HIGH){}
      if (digitalRead(EOI) == LOW){
        EOI_ = LOW;
      }
      pinMode(NRFD,OUTPUT);
      command[index] = (~PINC);
      index=index+1;
      pinMode(NDAC,INPUT);   //Allow NDAC to go high, data read
      while(digitalRead(DAV) == LOW){}
      pinMode(NDAC,OUTPUT);  //NDAC low for next read
      pinMode(NRFD,INPUT);   //NRFD high to signal ready
   } 

   Serial.println(command);
}

void Save(){
byte addr,command,drive;
bool EOI_;
char file_name[15];
int index;
File file_;
file_name[0] = '0';
file_name[1] = '/';  

Serial.println("Saving");
    pinMode(NRFD,INPUT);
// loop for file name
    index = 2;
    EOI_ = HIGH;
    while (EOI_ == HIGH){
      delay(1);
      while(digitalRead(DAV) == HIGH){}
      if (digitalRead(EOI) == LOW){
        EOI_ = LOW;
      }
      pinMode(NRFD,OUTPUT);
      delay(1);
      file_name[index] = (~PINC);
      if (file_name[3] == ':'){
        file_name[0] = char(file_name[2]);
        index= 1;
        file_name[3] = '0';
      }
      index=index+1;
      pinMode(NDAC,INPUT);   //Allow NDAC to go high, data read
      while(digitalRead(DAV) == LOW){}
      pinMode(NDAC,OUTPUT);  //NDAC low for next read
      pinMode(NRFD,INPUT);   //NRFD high to signal ready
   }
    file_name[index] ='.';
    file_name[index+1] ='P';
    file_name[index+2] ='R';
    file_name[index+3] ='G';
    file_name[index+4] ='\0';

    Serial.print("Saving file name = ");
    Serial.println(file_name);          //File name including drive path now assembled
       
    while(digitalRead(DAV) == HIGH){} 
    pinMode(NRFD,OUTPUT);
    command = (~PINC);
    pinMode(NDAC,INPUT);
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT);
    pinMode(NRFD,INPUT);

    while(digitalRead(DAV) == HIGH){} 
    pinMode(NRFD,OUTPUT);
    command = (~PINC);
    pinMode(NDAC,INPUT);
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT);
    pinMode(NRFD,INPUT);

    while(digitalRead(DAV) == HIGH){} 
    pinMode(NRFD,OUTPUT);
    command = (~PINC);
    pinMode(NDAC,INPUT);
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT);

    if (SD.exists(file_name)){
      SD.remove(file_name);
    }
    file_ = SD.open(file_name, FILE_WRITE);
    pinMode(NRFD,INPUT);
    
    index = 0;
    EOI_ = HIGH;
    while (EOI_ == HIGH){
      while(digitalRead(DAV) == HIGH){}
      if (digitalRead(EOI) == LOW){
        EOI_ = LOW;
      }
      pinMode(NRFD,OUTPUT);
      file_.write(~PINC);
      digitalWrite(LED_BUILTIN, bitRead(PINC,7));
      pinMode(NDAC,INPUT);   //Allow NDAC to go high, data read
      while(digitalRead(DAV) == LOW){}
      pinMode(NDAC,OUTPUT);  //NDAC low for next read
      pinMode(NRFD,INPUT);   //NRFD high to signal ready
    }
    file_.close();
    digitalWrite(LED_BUILTIN, LOW);   
    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(1);
    addr = ~PINC ;
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT);

    pinMode(NRFD,INPUT);
    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(1);
    addr = ~PINC ;
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT);

    pinMode(NRFD,INPUT);
    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(1);
    addr = ~PINC ;
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT);
    
    pinMode(NRFD,INPUT);
    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(1);
    addr = ~PINC ;
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT);
    
    pinMode(NRFD,INPUT);
    delay(200);
    Serial.println("save complete");
    return;
}

void Load(){
byte addr,command,data,drive,file_name_length;
bool EOI_;
char file_name[15],directory[2];
unsigned int index,offset,size_offset;
unsigned int size_;
File file_;
File dir;
bool eof;

 byte footer[] = {0xDD,0x04,0xFF,0xFF,0x42,0x4C,0x4F,0x43,0x4B,0x53,0x20,0x46,0x52
                 ,0x45,0x45,0x2E,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20
                 ,0x20,0x20,0x20,0x00,0x00,0x00};
 byte header[] = {0x01,0x04,0x1F,0x04,0x00,0x00,0x12,0x22,0x50,0x45,0x54,0x44,0x49
                 ,0x53,0x4B,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x22,0x20
                 ,0x38,0x38,0x20,0x32,0x43,0x00};
 byte fname[]  = {0x3F,0x04,0x01,0x00,0x20,0x20,0x20,0x20,0x41,0x41,0x41,0x41,0x41
                 ,0x41,0x41,0x41,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20
                 ,0x50,0x52,0x47,0x20,0x20,0x00};                     
Serial.println("Loading");
drive=0;
file_name[0] = '0';
file_name[1] = '/';
// loop for file name
    index = 2;
    EOI_ = HIGH;
    while (EOI_ == HIGH){
      pinMode(NRFD,INPUT);   //NRFD high to signal ready
      delay(1);
      while(digitalRead(DAV) == HIGH){}
      if (digitalRead(EOI) == LOW){EOI_ = LOW;}
      pinMode(NRFD,OUTPUT);
      file_name[index] = (~PINC);
      if (file_name[3] == ':'){
        file_name[0] = char(file_name[2]);
        index= 1;
        file_name[3] = '0';
      }
      index=index+1;
      pinMode(NDAC,INPUT);   //Allow NDAC to go high, data read
      while(digitalRead(DAV) == LOW){}
      pinMode(NDAC,OUTPUT);  //NDAC low for next read
   }
   file_name[index] ='.';
   file_name[index+1] ='P';
   file_name[index+2] ='R';
   file_name[index+3] ='G';
   file_name[index+4] ='\0';
 
   Serial.print("Loading file name = ");
   Serial.println(file_name);
 
    pinMode(NRFD,INPUT);
    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // Stop data
    addr = ~PINC ;                              // UNL 0x3f
    pinMode(NDAC,INPUT);  // Set accept flag
    while(digitalRead(DAV) == LOW){}
    delay(1);
    pinMode(NDAC,OUTPUT); // Clear accept flag
    delay(1);
    
    pinMode(NRFD,INPUT);
    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // Stop data
    addr = ~PINC ;                              // TAG 08 0x48
    pinMode(NDAC,INPUT);  // Set accept flag
    while(digitalRead(DAV) == LOW){}
    delay(1);
    pinMode(NDAC,OUTPUT); // Clear accept flag
    delay(1);
    
    pinMode(NRFD,INPUT);
    while(digitalRead(DAV) == HIGH){}
    delay(1);
    pinMode(NRFD,OUTPUT); // Stop data
    addr = ~PINC ;                              // SCG 00 0x60
    pinMode(NDAC,INPUT);  // Set accept flag low
    while(digitalRead(DAV) == LOW){}
    delay(1);
    pinMode(NDAC,OUTPUT); // Clear accept flag
    delay(1);

// Step 10 to 21 - Device is now the talker
    Serial.println("");
    Serial.println("Sending file to the PET");
    DDRC = B11111111;
    pinMode(NRFD,INPUT);
    pinMode(NDAC,INPUT);
    digitalWrite(DAV,LOW);
    pinMode(DAV,INPUT);

// #########################Send directory list########################################    
    if (file_name[2] == '$') {
    header[4] = file_name[0] - 48;
    if (file_name[3] != '.'){file_name[0] = file_name[3];}
    Serial.println("dir command");
    Serial.println(file_name);
    EOI_ = HIGH;
    while (EOI_ == HIGH){
 
        for (index = 0;index <32;index++){
          data=header[index];
          PORTC= ~data;
          while(digitalRead(NRFD) == 0){}
          pinMode(DAV,OUTPUT);
          while(digitalRead(NDAC) == LOW){}
          pinMode(DAV,INPUT);
          }

    eof = false;
    offset = 0x043F;

    directory[0] = file_name[0];
    directory[1] = file_name[1];
    directory[2] = '\0';
    dir = SD.open(directory);

    while(true){
      File entry =  dir.openNextFile();
      if (! entry) {break;}
      char* names = entry.name();
      fname[0] = lowByte(offset);
      fname[1] = highByte(offset);
      fname[2] = lowByte(entry.size()/256);
      fname[3] = highByte(entry.size()/256);
      size_offset = 8;
      if (fname[2] <=9){fname[2] =10;}
      for(int i=0;i<=8;i++){fname[i+8] = 0x20;}
      
      for(int i=0;i<=7;i++){
          fname[i+size_offset] = names[i];
          if (names[i+1] == '.'){
            i = 9;
          }
      }
      
        offset = offset + 0x20;
        entry.close();
        for (index = 0;index <32;index++){
          digitalWrite(LED_BUILTIN, bitRead(index,7));
          data=fname[index];
          PORTC= ~data;
          while(digitalRead(NRFD) == 0){}
          pinMode(DAV,OUTPUT);
          while(digitalRead(NDAC) == LOW){}
          pinMode(DAV,INPUT);
         }
       }
       dir.close();
       Serial.println("file names sent");
       for (index = 0;index <32;index++){
         data=footer[index];
         PORTC= ~data;
         while(digitalRead(NRFD) == 0){}
         pinMode(DAV,OUTPUT);
         while(digitalRead(NDAC) == LOW){}
         pinMode(DAV,INPUT);
       }
       EOI_ = LOW;
       pinMode(EOI,OUTPUT);
       delay(10);
      }
      pinMode(DAV,OUTPUT);
      while(digitalRead(NDAC) == LOW){}
      delay(0); 
      pinMode(DAV,INPUT);
      pinMode(EOI,INPUT);
    }
// ####################################Send file ############################################
          
    else if (SD.exists(file_name)){
      EOI_ = HIGH;
      index = 0;
      file_ = SD.open(file_name, FILE_READ);
      size_ = file_.size();

      while (EOI_ == HIGH) {         
        // digitalWrite(LED_BUILTIN, bitRead(index,7));
        data=file_.read();

        while(digitalRead(NRFD) == 0){}
        PORTC= ~data;
        index = index +1;
        if (index == (size_)){
          EOI_ = LOW;
          pinMode(EOI,OUTPUT);
        }      
        pinMode(DAV,OUTPUT);
 //       delay(1);
        while(digitalRead(NDAC) == LOW){}
 //       delay(1);
        pinMode(DAV,INPUT);
      }
    pinMode(EOI,INPUT);
    file_.close();
    digitalWrite(LED_BUILTIN, LOW);
    }
    else {
      Serial.println("");
      Serial.println("File not found");
 //     pinMode(EOI,OUTPUT);
 //     pinMode(DAV,OUTPUT);
 //     while(digitalRead(NDAC) == LOW){}
 //     pinMode(DAV,INPUT);
 //     pinMode(EOI,INPUT);
    }
 
// steps 22 to 25
    digitalWrite(NRFD,LOW);
    pinMode(NRFD,OUTPUT);
    pinMode(NDAC,OUTPUT);
    pinMode(EOI,INPUT);
    pinMode(DAV,INPUT); 
    DDRC = B00000000;
    
  MCUSR |= _BV(PUD);    
    delay(10);
    digitalWrite(NRFD,HIGH);
    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(5);
    addr = ~PINC ;                              // UNT
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT); 
    pinMode(NRFD,INPUT);

    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(1);
    addr = ~PINC ;                              // LAG 08
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT); 
    pinMode(NRFD,INPUT);

    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(1);
    addr = ~PINC ;                              // SCG 00
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT); 
    pinMode(NRFD,INPUT);

    while(digitalRead(DAV) == HIGH){}
    pinMode(NRFD,OUTPUT); // set low
    delay(1);
    addr = ~PINC ;                              // UNL
    pinMode(NDAC,INPUT);  // allow to go high
    while(digitalRead(DAV) == LOW){}
    pinMode(NDAC,OUTPUT); 
    pinMode(NRFD,INPUT);
        
    Serial.println("load complete");

return;
}

void printDirectory(File dir, int numTabs) {
  while (true) {

    File entry =  dir.openNextFile();
    if (! entry) {
      // no more files
      break;
    }
    for (uint8_t i = 0; i < numTabs; i++) {
      Serial.print('\t');
    }
    Serial.print(entry.name());
    if (entry.isDirectory()) {
      Serial.println("/");
      printDirectory(entry, numTabs + 1);
    } else {
      // files have sizes, directories do not
      Serial.print("\t\t");
      Serial.println(entry.size(), DEC);
    }
    entry.close();
  }
}


void loop() {

   if (digitalRead(ATN) == 0) {
      pinMode(NRFD,INPUT);
      pinMode(NDAC,OUTPUT); 
      Serial.println("ATN low");
      ATN_();
   }
 }