//////////////////////////////////////////////////////////////////////////////////////
// KCX_BT_EMITTER v1.7
// Author: Mark Olson 2020-09-03
// Rubber Band Gun - https://github.com/Mark-MDO47/RubberBandGun
// When running the sketch, you can select steps in any order as follows:
//     https://item.taobao.com/item.htm?spm=a21wu.12321156-tw.0.0.7e76d1c7xEOcFZ&id=570274835710
//     https://www.electro-tech-online.com/threads/kcx_bt_emitter-low-cost-bluetooth-bt-audio-module.158156/

#include "Arduino.h"
#include "SoftwareSerial.h"  // to talk to KCX_BT_EMITTER without using up debug serial port

#define DPIN_BLUESRL_RX 2  // serial in  - talk to Bluetooth module (KCX_BT_EMITTER) - connect to YELLOW wire
#define DPIN_BLUESRL_TX 3  // serial out  - talk to Bluetooth module (KCX_BT_EMITTER) - connect to GREEN wire

SoftwareSerial BTSerial(DPIN_BLUESRL_RX, DPIN_BLUESRL_TX);  // to talk to Bluetooth
SoftwareSerial DFSerial(10, 11);  // RX, TX

#define NUMWAIT 500  // loopcount waiting for response from Bluetooth module

#define NUMOF(a) (sizeof((a)) / sizeof(*(a)))

uint8_t DEBUG_SERIAL_IN = 0;  // 1 to debug the serial input code

char inBytes[100];

char cmd_bld_ADDLINKADD[32];   // must build these in RAM from user input
char cmd_bld_ADDLINKNAME[64];  // must build these in RAM from user input

void setup() {

	Serial.begin(115200);  // this is for general debug
	while (!Serial); // wait for serial port to connect. Needed for native USB port only
	BTSerial.begin(115200);  // this is control for Bluetooth module (KCX_BT_EMITTER)
}

void loop() {
	static uint8_t menuPrinted = 0;

	if (0 == menuPrinted) {
		menuPrinted = 1;
		Serial.println("");
		Serial.println("   1 - Scan for Bluetooth receiver devices (such as speaker, headphones, etc.)");
		Serial.println("   2 - Display stored auto-connect Bluetooth receiver devices");
		Serial.println("   3 - Add one auto-connect Bluetooth receiver device to storage");
		Serial.println("   4 - Delete all auto-connect Bluetooth receiver devices from storage");
		Serial.println("   5 - Current status");
		Serial.println("   6 - BT Disconnect");
		Serial.println("   7 - PowerOff module");
		Serial.println("   8 - Auto Connect Setting");
		Serial.print("==> ");
	}

	if (Serial.available()) {
		menuPrinted = 0;
		processCommand();
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// processCommand(uint8_t theChoice)
//    performs one of the four menu options
//    as needed, reports scan info from Bluetooth
//
void processCommand() {
	uint8_t addlinkOk = 0;

	getSerial_chars();
	reportBlueCom();
	switch (inBytes[0]) {
		case '1':  // 1 - Scan for Bluetooth receiver devices (such as speaker, headphones, etc.)");
			Serial.println("\n1=SCAN");
			sendBlueCmd("AT+");
			sendBlueCmd("AT+RESET");
			sendBlueCmd("AT+");

			// Scan for any visible Bluetooth devices
			sendBlueCmd("AT+PAIR");
			delay(100);

			// need to hang around a little more
			loopReportBlueCom();
			break;
		case '2':  // 2 - Display stored auto-connect Bluetooth receiver devices");
			Serial.println("\n2=DISPLAY");
			sendBlueCmd("AT+");
			// sending this command returns all information recorded in the automatically reconnect MAC and device name memory.
			sendBlueCmd("AT+VMLINK?");
			delay(500);
			break;
		case '3':  // 3 - Add one auto-connect Bluetooth receiver device to storage");
			// You can have up to 10 auto-connect Bluetooth receiver devices in storage
			// The Bluetoth module will connect to the first device it finds in order
			// NOTE: must be exactly 12 characters for hex string
			Serial.println("\n3=ADD");
			addlinkOk = buildADDLINKADD(cmd_bld_ADDLINKADD, NUMOF(cmd_bld_ADDLINKADD) - strlen("AT+ADDLINKADD="));
			if (0 != addlinkOk) {
				reportBlueCom();
				addlinkOk = buildADDLINKNAME(cmd_bld_ADDLINKNAME, NUMOF(cmd_bld_ADDLINKNAME) - strlen("AT+ADDLINKNAME=") - 2);
			}
			if (0 != addlinkOk) {
				reportBlueCom();
				sendBlueCmd("AT+");
				sendBlueCmd("AT+DISCON");
				sendBlueCmd("AT+VMLINK?");

				// associate the Bluetooth device name with internal list of MAC addresses for auto-connection
				// Set the memory. When the module is started , it will search the MAC address of the device and the MAC address of the recording area.
				// The address is automatically connected to any one of the MAC addresses of the recording area,
				//  and is not connected when the address is not consistent, so as to achieve the specified MAC address connection.
				sendBlueCmd(cmd_bld_ADDLINKADD);
				sendBlueCmd(cmd_bld_ADDLINKNAME);

//			sendBlueCmd("AT+RESET");
				sendBlueCmd("AT+");
				sendBlueCmd("AT+VMLINK?");
				// need to hang around a little more
				loopReportBlueCom();
			} else {
				reportBlueCom();
				Serial.println("");
				Serial.println("User aborted storing MAC address for the Bluetooth speaker or headphones\n");
			}
      break;
		case '4':  // 4 - Delete all auto-connect Bluetooth receiver devices from storage");
			Serial.println("\n4=DELETE ALL");
			sendBlueCmd("AT+");
			sendBlueCmd("AT+DISCON");
			sendBlueCmd("AT+DELVMLINK");
			sendBlueCmd("AT+RESET");
			sendBlueCmd("AT+");
			sendBlueCmd("AT+VMLINK?");
      loopReportBlueCom();
			break;
		case '5':  // 5 - Show current status");
			Serial.println("\n5=STATUS");
			sendBlueCmd("AT+");
			sendBlueCmd("AT+GMR?");
			sendBlueCmd("AT+BAUD?");
			sendBlueCmd("AT+STATUS?");
			loopReportBlueCom();
			break;
		case '6':  // 6 - Disconnect current BT");
			Serial.println("\n6=Disconnect");
			sendBlueCmd("AT+");
			sendBlueCmd("AT+DISCON");
			loopReportBlueCom();
			break;
		case '7':  // 7 - PowerOff module");
			Serial.println("\n7=PowerOff module");
			sendBlueCmd("AT+");
			sendBlueCmd("AT+POWER_OFF");
			loopReportBlueCom();
			break;
		case '8':  // 7 - PowerOff module");
			Serial.println("\n8=Auto Connect Setting");
			sendBlueCmd("AT+");
			sendBlueCmd("AT+DISCON");
			sendBlueCmd("AT+DELVMLINK");
			sendBlueCmd("AT+ADDLINKADD=0f1939d72316");
			sendBlueCmd("AT+ADDLINKNAME=HW-BT");
			sendBlueCmd("AT+ADDLINKADD=014d0b2d4241");
			sendBlueCmd("AT+ADDLINKNAME=MT");
			loopReportBlueCom();
			break;
		case 'A':  // AT Command
			Serial.print("\n");
			if (strncmp(inBytes,"AT+",3)==0) {
				sendBlueCmd(inBytes);
				loopReportBlueCom();
			}
			break;
  }  // end switch()
  Serial.println("\n--- KCX_BT_EMITTER PROGRAMMING STEP COMPLETE ---");
}  // end processCommand()

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// buildADDLINKADD(char * cmdAddr, uint16_t cmdMaxLen)
//    builds a RAM AT+ADDLINKADD command from user input
//
// NOTE: the hex MAC Address sent in the AT command must be exactly 12 characters
//
uint8_t buildADDLINKADD(char *cmdAddr, uint16_t cmdMaxLen) {
	char myLowerCase[15];  // never want to over-run
	uint8_t myNumChars = 0;
	uint8_t myStart = 0;
	char const *zeroFill = "000000000000";
	Serial.println("");
	Serial.println("Enter the unique MAC address for the Bluetooth speaker or headphones; it starts with 0x");
	Serial.println("    upper or lower case does not matter; maximum of 12 characters after the 0x");
	Serial.println("To abort adding an auto-connect Bluetooth receiver device to storage, just enter an empty line");
	Serial.print("==> ");
	while (!Serial.available());  // wait
	// reportBlueCom();
	myNumChars = getSerial_chars();
	if (0 == myNumChars) return (0);  // abort
	if (('0' == inBytes[0]) && ('x' == tolower(inBytes[1]))) myStart = 2;
	myNumChars -= myStart;
	if (DEBUG_SERIAL_IN) {
		Serial.print("   input string |");
		Serial.print(inBytes);
		Serial.print("| myStart ");
		Serial.print(myStart);
		Serial.print(" myNumChars ");
		Serial.println(myNumChars);
	}  // end if (DEBUG_SERIAL_IN)
	if (myNumChars > 12) {
		Serial.println("Abort - more than 12 characters");
		return (0);  // abort
	}
	for (int j = myStart; (j < (myNumChars + myStart)) && (0 != inBytes[j]); j++) {
		if (0 == isxdigit(inBytes[j])) {
			Serial.print("Abort - non-hex digit: ");
			Serial.print(inBytes[j]);
			Serial.print(" j ");
			Serial.println(j);
			return (0);  // abort
		}
		myLowerCase[j] = tolower(inBytes[j]);
	}
	myLowerCase[myNumChars + myStart] = 0;
	Serial.print("\nYour entry \"");
	Serial.print(inBytes);
	Serial.println("\" was accepted");
//	strcpy(cmdAddr, "AT+ADDLINKADD=0x");
	strcpy(cmdAddr, "AT+ADDLINKADD=");
	strcat(cmdAddr, &zeroFill[myNumChars]);
	strcat(cmdAddr, &myLowerCase[myStart]);
	return (1);  // successful command build
}  // end buildADDLINKADD()

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// buildADDLINKNAME(char * cmdAddr, uint16_t cmdMaxLen)
//    builds a RAM AT+ADDLINKNAME command from user input
//
uint8_t buildADDLINKNAME(char *cmdAddr, uint16_t cmdMaxLen) {
	uint8_t myNumChars = 0;
	char const *zeroFill = "000000000000";
	Serial.println("");
	Serial.println("Enter the name you choose for this device; it is OK to place spaces between words");
	Serial.println("    maximum of 20 characters total");
	Serial.println("To abort adding an auto-connect Bluetooth receiver device to storage, just enter an empty line");
	Serial.print("==> ");
	while (!Serial.available());  // wait
	// reportBlueCom();
	myNumChars = getSerial_chars();
	if (0 == myNumChars) return (0);  // abort
	if (myNumChars > 20) {
		Serial.println("Abort - more than 20 characters");
		return (0);  // abort
	}
	Serial.print("\nYour entry \"");
	Serial.print(inBytes);
	Serial.println("\" was accepted");
	strcpy(cmdAddr, "AT+ADDLINKNAME=");
	strcat(cmdAddr, inBytes);
	return (1);  // successful command build
}  // end buildADDLINKNAME()

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// getSerial_chars()
//    gets character string from USB serial; removes EOL chars; stores in inBytes[] zero terminated
//
//    returns number of characters in inBytes
//
// no code to flag input over-run
// stores zero-terminated string in inBytes
//
uint8_t getSerial_chars() {
	static unsigned char myChar;
	static uint8_t idx = 0;

	idx = 0;
	while (1) {
		if (Serial.available()) {
			myChar = Serial.read();
			if (DEBUG_SERIAL_IN) {
				Serial.print("\n  getSerial_chars got myChar 0x");
				Serial.print(myChar, HEX);
			}                             // end if(DEBUG_SERIAL_IN)
			if (((int)myChar) >= 0x20) {  // if it is space or higher
				Serial.write(myChar);
				if (DEBUG_SERIAL_IN) Serial.print(" >= 0x20 ");
				if ((idx + 2) <= NUMOF(inBytes)) {
					inBytes[idx++] = myChar;
					if (DEBUG_SERIAL_IN) {
						Serial.print("count of inBytes #");
						Serial.println(idx);
					}  // end if(DEBUG_SERIAL_IN)
				} else {
					if (DEBUG_SERIAL_IN) {
						Serial.print(" not stored; idx ");
						Serial.print(idx);
						Serial.print(" not stored; NUMOF(inBytes) ");
						Serial.println(NUMOF(inBytes));
					}  // end if(DEBUG_SERIAL_IN)
				}
				delay(5);
			} else {
				delay(5);
				if (DEBUG_SERIAL_IN) {
					Serial.print(" --- not stored! Count of inBytes #");
					Serial.println(idx);
				}  // end if(DEBUG_SERIAL_IN)
				while (Serial.available()) {
					myChar = Serial.read();
					delay(5);
				}
				break;
			}
		}  // end try to read input to the end of line
	}

	inBytes[idx] = 0;
	if (DEBUG_SERIAL_IN) {
		Serial.print("\n  getSerial_chars idx ");
		Serial.print(idx);
		Serial.print(" inBytes[idx] 0x");
		Serial.print(inBytes[idx], HEX);
		Serial.print(" inBytes |");
		Serial.print(inBytes);
		Serial.println("|");
	}  // end if(DEBUG_SERIAL_IN)
	return (idx);
}  // end getSerial_chars()

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// getSerial_uint8_t()
//    gets single-digit decimal number from USB serial; returns the number itself (not ASCII)
//
uint8_t getSerial_uint8_t() {
	getSerial_chars();
	if (DEBUG_SERIAL_IN) {
		Serial.print("\n  getSerial_uint8_t inBytes[0] 0x");
		Serial.print(inBytes[0], HEX);
		Serial.print(" converted to ");
		Serial.println(uint8_t(inBytes[0] - 0x30), HEX);
	}                                     // end if(DEBUG_SERIAL_IN)
	return (uint8_t(inBytes[0] - 0x30));  // subtract ASCII 0
}  // end getSerial_uint8_t()

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// sendBlueCmd( char * cmd )
//    Sends one AT-style zero-terminated string to the Bluetooth module
//
void sendBlueCmd(char *cmd) {
	Serial.println(cmd); // send this before sending to device
	// BTSerial.println(cmd);
	while (*cmd) {
		BTSerial.write(*cmd);
		cmd++;
	}
	BTSerial.write(0x0d);
	BTSerial.write(0x0a);
	loopReportBlueCom();
}  // end sendBlueCmd()

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// reportBlueCom()
//    Reports back any response or scan output from the Bluetooth module
//    Returns number of characters seen
//
unsigned int reportBlueCom() {
	unsigned int idx = 0;
	unsigned int odx = 0;

	while (BTSerial.available()) inBytes[idx++] = BTSerial.read();
	if (idx > 0) {
		odx = 0;
		for (odx = 0; odx < idx; odx += 1) {
			Serial.write(inBytes[odx]);
			delay(5); // Waiting time to prevent garbled characters
		}
	}  // if anything received from Bluetooth chip
	return (idx);
}  // end reportBlueCom()

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// loopReportBlueCom()
//    Loops reporting back any response or scan output from the Bluetooth module
//    Returns number of characters seen on the last loop
//
unsigned int loopReportBlueCom() {
	int loopIdx;
	unsigned int numBytes;
	for (loopIdx = 0; loopIdx < NUMWAIT; loopIdx += 1) {
		numBytes = reportBlueCom();
		delay(5);
	}
	return (numBytes);
}  // end loopReportBlueCom()