//**********************************************************************

//                                                                     
// Program to run the K8055 from Windows using Borland BCC55
// and Toshiba numeric USB keyboard
// -------                                                            
//                                                                     
//slidec
//                    
// Available for use under the open source license of the Milwaukee
// Servo Electric Guitar Project www.servoelectricguitar.com.  All other
// rights reserved
//                                                           
//**********************************************************************


#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <time.h>
#include <windows.h>
#include "K8055D.h"
//#include <iostream.h>
//**********************************************************
//***global variables
//**********************************************************
//general variables

int stringtuning[3][13];
clock_t now, later;//time variable for delaying delta-time

//profiler variables
	clock_t starttime;

//******************************************************	
//***function prototypes
//******************************************************
char chordmode(void); //chord mode plays chords
//char normalmode(int); //normal mode plays note by striking keys
char tunemode(int); //tune mode tunes the strings
char playmode(void); //plays a midi file
void waitabit(void);  //delay to create sample and hold pulse
void wait(float seconds); //a waiting function
void profile();
void initializetuning();
void savetuning();
void loadtuning();

//*****************************************************
//**** delay timer
//*****************************************************
void wait(float seconds)//wait integer number of seconds
{
 	//printf("the seconds at wait function is %f\n",seconds);
 	//printf("clocks per tick is %d\n",CLOCKS_PER_SEC);
  clock_t endwait;
 	endwait = clock() + seconds * CLOCKS_PER_SEC;
	//printf("endwait is %d\n\n",endwait);
	while (clock()<endwait) {}
}
//*****************************************************
//**** profiler
//*****************************************************

void profile()//use for profiling program execution times
{
	starttime = clock();
	long int profileseconds;
	//printf("PROFILE this is ticks: %d\n", starttime);
	profileseconds=starttime/CLOCKS_PER_SEC;
	//printf("PROFILE this is seconds: %d\n", profileseconds);
	}
	
//********************************************************
//* initialize tuning (rough values are corrected after tuning
//********************************************************
 void initializetuning(void)

 {
  stringtuning[0][0]=10;  
  stringtuning[0][1]=18;
  stringtuning[0][2]=29;
  stringtuning[0][3]=47;
  stringtuning[0][4]=63;
  stringtuning[0][5]=79;
  stringtuning[0][6]=104;
  stringtuning[0][7]=129;
  stringtuning[0][8]=152;
  stringtuning[0][9]=181;
  stringtuning[0][10]=208;
  stringtuning[0][11]=241;
  stringtuning[0][12]=255;
  
 
  stringtuning[1][0]=10;
  stringtuning[1][1]=18;
  stringtuning[1][2]=29;
  stringtuning[1][3]=47;
  stringtuning[1][4]=63;
  stringtuning[1][5]=79;
  stringtuning[1][6]=104;
  stringtuning[1][7]=129;
  stringtuning[1][8]=152;
  stringtuning[1][9]=181;
  stringtuning[1][10]=208;
  stringtuning[1][11]=241;
  stringtuning[1][12]=255;
  
  
 
  stringtuning[2][0]=10;
  stringtuning[2][1]=18;
  stringtuning[2][2]=29;
  stringtuning[2][3]=47;
  stringtuning[2][4]=63;
  stringtuning[2][5]=79;
  stringtuning[2][6]=104;
  stringtuning[2][7]=129;
  stringtuning[2][8]=152;
  stringtuning[2][9]=181;
  stringtuning[2][10]=208;
  stringtuning[2][11]=241;
  stringtuning[2][12]=255;
 } 
  
//********************************************************
//*    save tuning corrections by player
//********************************************************	
void savetuning()
{	
	
  char onenumber[3];
  FILE *tfile = NULL; //open a file
	tfile=fopen("c:\\Borland/BCC55\\MIDI\\tuning.txt","w"); ///name file here
	if (tfile==NULL)
	{
		fprintf(stderr, "error in save opening"); 
		fflush(stderr);
	}
	else
	{
  	//get the tunings
  	clrscr;
  	for(int n=0; n<3; n++)
    {
      for(int m=0; m<13; m++)
      {
  	     itoa(stringtuning[n][m],onenumber,10); //convert int to string
         fputs(onenumber, tfile);//write a line
         fputc('\n', tfile);//write a line
  	  }
  	}   
    fclose(tfile);   
	}     
}//end savetunings
	
//********************************************************
//*    load tuning
//********************************************************	
void loadtuning()
{	
  char nothing;
  char onenumber[4];
  FILE *tfile = NULL; //open a file
	tfile=fopen("c:\\Borland/BCC55\\MIDI\\tuning.txt","r"); ///name file here
	if (tfile==NULL)
	{
		fprintf(stderr, "no tuning file"); 
		fflush(stderr);
	}
	else
	{
  	//get the tunings
  	for(int n=0; n<3; n++)
    {
      for(int m=0; m<13; m++)
      {
  	    fgets(onenumber, 5,tfile); //read a line
  	    stringtuning[n][m]=atoi(onenumber);
        //printf("this is the string i read %s                \n", onenumber);
        //nothing-getch();
  	  }    
  	}   
	}     
	     
}//end loadtunings

//*****************************************************
//**** chord mode (guitar keypad calls up chords)
//*****************************************************

 char chordmode()
{
    
  int doneflag=0;
  int notenumber1, notenumber2, notenumber3; //  a/d value
	int noteindex1, noteindex2, noteindex3;// 0-12 is d to d'

  notenumber1=6;
  notenumber2=6;
  notenumber3=6;

  noteindex1=6;
  noteindex2=6;
  noteindex3=6;

	clrscr();
	gotoxy(1,1);
	printf("Chord Mode                                      ");
	char inputkey='5';
	while ((inputkey!='X')&&(inputkey!='G')&&(inputkey!='K')&&(inputkey!='O')) // non-chord mode or exit
  {
  	if (kbhit())//new key
    {
      doneflag=0;
      inputkey=getch();//get the new key
      printf("new key hit");
      //profile();

     switch (inputkey)
      {
          case '0':
             noteindex1=0;
             noteindex2=4;
             noteindex3=7;
             break;
          case '.':
             noteindex1=1;
             noteindex2=5;
             noteindex3=8;
             break;
          case '1':
             noteindex1=2;
             noteindex2=6;
             noteindex3=9;
             break;
          case '2':
             noteindex1=3;
             noteindex2=7;
             noteindex3=10;
             break;
          case '3':
             noteindex1=4;
             noteindex2=8;
             noteindex3=11;
             break;
          case '4':
             noteindex1=5;
             noteindex2=9;
             noteindex3=0;
             break;
          case '5':
             noteindex1=6;
             noteindex2=10;
             noteindex3=1;
             break;
          case '6':
             noteindex1=7;
             noteindex2=11;
             noteindex3=2;
             break;
          case '7':
             noteindex1=8;
             noteindex2=0;
             noteindex3=3;
             break;
          case '8':
             noteindex1=9;
             noteindex2=1;
             noteindex3=4;
             break;
          case '9':
             noteindex1=10;
             noteindex2=2;
             noteindex3=5;
             break;
          case '/':
             noteindex1=11;
             noteindex2=3;
             noteindex3=6;
             break;
          case '*':
             noteindex1=0;
             noteindex2=4;
             noteindex3=7;
             break;
          default:
             noteindex1=1;
             noteindex2=5;
             noteindex3=8;
      }//switch
      notenumber1=stringtuning[0][noteindex1];
      notenumber2=stringtuning[1][noteindex2];
      notenumber3=stringtuning[2][noteindex3];
    
      ClearDigitalChannel(1);
      OutputAnalogChannel(1,notenumber1);
      waitabit();
      SetDigitalChannel(1);
      
      ClearDigitalChannel(2);
      OutputAnalogChannel(1,notenumber2);
      waitabit();
      SetDigitalChannel(2);   
      
      ClearDigitalChannel(3);
      OutputAnalogChannel(1,notenumber3);
      waitabit();
      SetDigitalChannel(3); 
    
    }//end of new key     
  } //no mode change key              
	return(inputkey);
}//end of chord mode

//*****************************************************
//**** tune (single note) mode
//*****************************************************

char tunemode(int wire)
{
	int notenumber;
	//clrscr();
	gotoxy(1,1);
	printf("Tune Mode for string: %d", wire);
	char inputkey='1';
	//char persistantinputkey;
	int noteindex=5;
	while ((inputkey!='X')&&(inputkey!='G')&&(inputkey!='K')&&(inputkey!='O')&&(inputkey!='R')) //possible mode change
  {  
 		inputkey=getch();//read the keyboard here **********************
 	  // check for mode change	
	  if ((inputkey!='X')&&(inputkey!='G')&&(inputkey!='K')&&(inputkey!='O'))//no mode change
    {
  		//play a note
      if (inputkey=='*'||(inputkey>='.' && inputkey<='9'))
      {  
    		switch (inputkey)
        {
          case '0': noteindex=0;
          break;
          case '.': noteindex=1;
          break;
          case '1': noteindex=2;
          break;
          case '2': noteindex=3;
          break;
          case '3': noteindex=4;
          break;
          case '4': noteindex=5;
          break;
          case '5': noteindex=6;
          break;
          case '6': noteindex=7;
          break;
          case '7': noteindex=8;
          break;
          case '8': noteindex=9;
          break;
          case '9': noteindex=10;
          break;
          case '/': noteindex=11;
          break;
          case '*': noteindex=12;
          break;
          default: noteindex=5;
         }
       }// play a note 
      gotoxy(1,3);
      //persistantinputkey=inputkey;
   		printf("pressed key = %c\n",inputkey);
   		printf("noteindex = %d     \n",noteindex);
  		notenumber = stringtuning[wire-1][noteindex];
  		OutputAnalogChannel(1,notenumber);
  		ClearDigitalChannel(wire);
  		waitabit();
  		SetDigitalChannel(wire);
  		gotoxy(1,5);
  		printf("D/A out = %d   \n",notenumber);
      //tune last note up    
        if (inputkey=='+')
        {
          if (stringtuning[wire-1][noteindex]<255)
          {
             ++stringtuning[wire-1][noteindex]; 
          } 	
        notenumber = stringtuning[wire-1][noteindex];
        OutputAnalogChannel(1,notenumber);
    		ClearDigitalChannel(wire);
    		waitabit();
    		SetDigitalChannel(wire);
    		gotoxy(1,5);
    		printf("D/A out = %d   \n",notenumber);
        }//end of tune up
        
        //tune last note down
        if (inputkey=='-')
        {
          if (stringtuning[wire-1][noteindex]>0) 
          {
           --stringtuning[wire-1][noteindex]; 
          } 
        notenumber = stringtuning[wire-1][noteindex];
        OutputAnalogChannel(1,notenumber);
    		ClearDigitalChannel(wire);
    		waitabit();
    		SetDigitalChannel(wire);
    		gotoxy(1,5);
    		printf("D/A out = %d   \n",notenumber);
        }//end of tune down
          
    }//no mode change
  }//while
	return(inputkey);
		
} //end of tuning mode




//*********************************************
//*** wait for a short while for the A/D converter
//*********************************************
void waitabit (void)
{

	now=clock();
	later=now+(50);//was 75  very close to 50 milliseconds
	while(now<later)
	{
		now=clock();
	}

}//end of waitabit



//***************************************************************
//**************************************************************
//*** main function 
//***************************************************************
//**************************************************************
int main(void)
{
///variables
   char inputkey;
   
///Open the device
   long data, adr;
   long whoops;
   clrscr;
   
   whoops=OpenDevice(1);//set up for USB address 1
   if (whoops==-1) 
    {
	    printf("cannot open device 1--proceed?");
	    inputkey=getch();
    }
// call different function
    WriteAllDigital(0);
    inputkey='G';  //start at string 1
    clrscr();
    initializetuning();//default tuning if no tuning file
    loadtuning();//try to load tuning file
    while (inputkey!='X') //while not quit 
    {
      //printf("made it to main");
    
    	if (inputkey=='G') //play/tune string 1
    	{      
    		inputkey=tunemode(1);//send to tunemode with string 1
    	}
    	if (inputkey=='K') //play/tune string 2
    	{      
    		inputkey=tunemode(2);//send to tunemode with string 2
    	}
    	if (inputkey=='O') //play/tune string 3
    	{      
    		inputkey=tunemode(3);//send to tunemode with string 3
    	}
    	if (inputkey=='R') //chord mode
    	{      
    		inputkey=chordmode();
    	}	
    }
   WriteAllDigital(0);
   CloseDevice;
   savetuning();

} /* End */