/*
	SC-01 Controller v0.3
	Anthony D'Angelo
	February 2024

	A sketch for controlling an SC-01 Speech Synthesizer chip.
	Documentation for the SC-01 is here: http://redcedar.com/sc01/sc01.pdf

	TODO:
	- Implement switch for Vowel Grid Mode
	- Implement 1v/octave tunable clock
	- Troubleshoot gate pushbutton
		- currently "sticks" but that may be a wokwi issue
		- may need to separate analog and digital ground?
	- Implement dynamic prefs
		- currently, advanceModeSelect and phonemeModeSelect are only checked at the beginning of each loop()
		- I thiiink this is what interrupts are for but idk lol
	- Implement memorized phrases
	- Maybe an LCD screen for user friendliness
	
	CHANGELOG
	- Added Vowel Grid Mode using pointers (!)
	- Added serial output, removed parallel output
	- Added switches for phoneme and advance mode select
	- Added pushbutton for gate advance mode
	- Added shift register and LEDs
*/

//Default preferences
const int phonemeMode = 1; // 1 = Saved phrase; 2 = Random phrase; 3 = Vowel grid
const int advanceMode = 1; // 1 = advance on ar pin high; 2 = advance on gate pin high
const bool repeat = true; // only loops once if false
const bool repeatDelay = 1000; // delay between loops

//Saved phrases
const int mem1Len = 3;
const String mem1Symbols[mem1Len] = {"K", "AH1", "R"}; // car
const int mem1Inflections[mem1Len] = {3,2,1};

const int mem2Len = 14;
const String mem2Symbols[mem2Len] = {"H", "EH1", "UH3", "L", "UH3", "O1", "U1", "PA0", "W", "ER" ,"R","UH1", "L","D"}; // Hello world
const int mem2Inflections[mem2Len] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};

//Pins
const int stb = 2;       // To SC-01 Strobe pin
const int ar = 3;        // To SC-01 A/R pin
	// 74HC595 pins 
const int datapin = 4;   // To DS
const int clockpin = 5;  // To SHCP
const int latchpin = 6;  // To STCP
	// Interface pins
const int gate = 7;      // +5v Eurorack Gate, simulated by pushbutton
const int phonemeModeSelect1 = 8;  // To mode switch 1 right pin
const int phonemeModeSelect2 = 9; // to mode switch 2 right pin
const int advanceModeSelect = 10; // To mode switch 3 right pin
const int rdm = A0;      // No connection; noise source for randomSeed()
const int gridX = A1;    // +5v Eurorack CV
const int gridY = A2;    // +5v Eurorack CV
	// Debug
const int arsim = 13;    // Simulates SC-01 A/R pulse out

//Valid phoneme symbols
const String validSymbols[64] = {
	"EH3", "EH2", "EH1", "PA0", "DT", "A2", "A1", "ZH", 
	"AH2", "I3", "I2", "I1", "M", "N", "B", "V", 
	"CH", "SH", "Z", "AW1", "NG", "AH1", "OO1", "OO", 
	"L", "K", "J", "H", "G", "F", "D", "S", 
	"A", "AY", "Y1", "UH3", "AH", "P", "O", "I", 
	"U", "Y", "T", "R", "E", "W", "AE", "AE1", 
	"AW2", "UH2", "UH1", "UH", "O2", "O1", "IU", "U1",
	"THV", "TH", "ER", "EH", "E1", "AW", "PA1", "STOP"
};

//Vowel grid
int vowelGrid[8][5] = {
	{44, 59, 46, 51, 22},
	{60, 2, 47, 50, 43},
	{41, 1, 36, 49, 58},
	{34, 0, 21, 35, 24},
	{39, 32, 8, 38, 54},
	{11, 6, 61, 53, 40},
	{10, 5, 19, 52, 55},
	{9, 33, 48, 23, 45}
};

bool arListen(int mode){
//Return true if AR pulse is detected
	if(mode==1){
		digitalWrite(arsim,HIGH); // debug only
		return digitalRead(ar)==HIGH ? true : false;
	}
	if(mode==2){
		return digitalRead(gate)==HIGH ? true : false;
	}
}

void strobe(){
//Trigger SC-01 latch
	digitalWrite(stb,HIGH);
	Serial.println(F("Strobe!"));
	delay(150);
	digitalWrite(stb,LOW);
}

void shiftUpdate(byte data){
//Write a given byte to shift register
	shiftOut(datapin, clockpin, MSBFIRST, data);
	digitalWrite(latchpin,HIGH);
	digitalWrite(latchpin,LOW);
}

int getPhonemeMode(){
	bool sw1 = digitalRead(phonemeModeSelect1)==HIGH;
	bool sw2 = digitalRead(phonemeModeSelect2)==HIGH;
	if (!sw1 && !sw2){
		return 1;
	}
	else if (sw1 && sw2){
		return 2;
	}
	else if (sw1 && sw2){
		return 3;
	}
	else if (sw1 && sw2){
		return 3;
	}
}

int getAdvanceMode(){
	return digitalRead(advanceMode)==HIGH ? 2:1;
}




// class preferences{
// 	public:
// 	int phonemeMode = phonemeMode; // 1 = Saved phrase; 2 = Random phrase; 3 = Vowel grid
// 	int advanceMode = advanceMode; // 1 = advance on ar pin high; 2 = advance on gate pin high
// 	bool repeat = repeat; // only loops once if false
// 	bool repeatDelay = repeatDelay; // delay between loops

// 	void set(){
// 		phonemeMode = digitalRead(phonemeModeSelect)==HIGH ? 2:1;
// 		advanceMode = digitalRead(advanceModeSelect)==HIGH ? 2:1;
// 	}
// };

class Phrase{
	public: 
		int len;
		String symbols[16];
		int inflections[16];

		int randomLen(){
		//Return a random length
			randomSeed(analogRead(rdm));
			int minLen = 4;
			int maxLen = 10;
			return random(minLen,maxLen);
		}

		int randomSymbolIndex(){
		//Return a random index from validSymbols[]
			randomSeed(analogRead(rdm));
			int index = random(0,63);
			return index;
		}

		int randomInflection(){
		//Return a random inflection value
			return random(0,3);
		}

		int indexFromVowelGrid(){
			int x = map(analogRead(gridX),0,1023,0,7);
  		int y = map(analogRead(gridY),0,1023,0,4);
			Serial.println("Vowel Grid index = " + String(x) + " , " + String(y));
			return vowelGrid[x][y];
		}
};

class Phoneme{
	public:
		String symbol = "PA0";
		int inflection = 0;

		int symbolIndex(){
		// Return index of given phoneme symbol if found in validSymbols[], 
		// or default to PA0 if symbol is not found.
			for (int i=0; i<64; i++){
				if(symbol==validSymbols[i]){
					return i;
				}
			}
			return 3;
		}
		
		int checkInflection(){
		// Return inflection if inflection is 0 to 3; otherwise, default to 0
			if(inflection >= 0 && inflection<4){
				return inflection;
			}
			else{
				return 0;
			}
		}

		byte encode(int phon, int inf){
		// Return an 8-bit value where 
		//   - the first two bits represent inflection
		//   - the last 6 bits represent the phoneme
			byte newByte = inf << 6;
			newByte = newByte | phon;
			Serial.println(F("Encoded output: "));
			for (int i=7; i>=0;i--){
				Serial.print(bitRead(newByte,i));
			}
			Serial.println();
			return newByte;
		}
};

//SETUP=========================================================
void setup(){
	Serial.begin(9600);
	Serial.println(F("PROGRAM START."));
	Serial.println();
	int inputPins[8] = {ar,rdm,gate,gridX,gridY,phonemeModeSelect1,phonemeModeSelect2,advanceModeSelect};
	for (int i=0;i<8;i++){
		pinMode(inputPins[i],INPUT);
	}
	int dataPins[5]={datapin,clockpin,latchpin,stb,arsim};
	for(int i=0; i<3; i++){
		pinMode(dataPins[i],OUTPUT);
	}
	Serial.println(F("Pins initialized."));
	Serial.println();
}

//LOOP===========================================================
void loop(){
	Serial.println(F("MAIN LOOP START:"));
	digitalWrite(arsim,LOW); // debug only

	Phrase phrase;
	int pMode = getPhonemeMode();
	int aMode = getAdvanceMode();

	if (pMode == 1){
		//Populate phrase with data from memory
		Serial.println(F("Phoneme Mode: Memory"));
		phrase.len = mem1Len;
		for(int i=0; i<phrase.len; i++){
			phrase.symbols[i]=mem1Symbols[i];
      phrase.inflections[i]=mem1Inflections[i];
			Serial.println("Phoneme " + String(i) + ": " + String(phrase.symbols[i]) + ", " + String(phrase.inflections[i]));
		}
		Serial.println();
	}

	if (pMode == 2){
		//Populate phrase with random phonemes
		Serial.println(F("Phoneme Mode: Random"));
		phrase.len = phrase.randomLen();
		for (int i=0; i<phrase.len; i++){
			String* ptr = &validSymbols[phrase.randomSymbolIndex()];
      phrase.symbols[i] = *ptr;
      phrase.inflections[i] = 0;
      Serial.println("Random phoneme " + String(i+1) + ": " + String(phrase.symbols[i]) + ", " + String(phrase.inflections[i]));
    }
		Serial.println();
	}

	if (pMode == 3){
		//Populate phrase with a single vowel
		Serial.println(F("Phoneme mode: Vowel Grid"));
		//Design note: this is implemented as joystick input here, but could easily just be 1/8" jacks for cv input
		phrase.len = 1;
		String* ptr = &validSymbols[phrase.indexFromVowelGrid()];
  	phrase.symbols[0] = *ptr;
		phrase.inflections[0]=0;
	}

	for (int i=0; i<phrase.len; i++){
	//Write phonemes in phrase
		Phoneme p;
		p.symbol = phrase.symbols[i];
		p.inflection = phrase.inflections[i];
		Serial.println("Writing phoneme " + String(i+1) + ": " + String(p.symbol) + ", " + String(p.inflection));
		int a = p.symbolIndex();
		int b = p.checkInflection();
		shiftUpdate(p.encode(a,b));
		while(!arListen(aMode)){
			delay(1);
			Serial.println(F("Waiting for AR pulse..."));
		}
		Serial.println(F("AR pulse detected!"));
		strobe();
		digitalWrite(arsim,LOW); // debug only
		Serial.println(F("Ready for next phoneme. \n"));
	}
	if(!repeat){
		Serial.println(F("END PROGRAM."));
		delay(500);
		exit(0);
	}
	delay(repeatDelay);
};