main.cpp

#include <iostream>
#include <unistd.h>
#include "MFRC522.h"
#include <string>
#include <cstdlib>
#include <fstream>
#include <climits>
#include <iomanip>
#include <sstream>
#include <pigpio.h>
#include "miniaudio.cpp"
#include <ctime>
#include "rotary_encoder.hpp"
enum PIN{PLAY=21,VOL_A=19,VOL_B=13, PLAY_LED=22,STOP_LED=27};
enum PinState{OFF,ON,FLASH1,FLASH2};

void play_song(std::string fname);
std::string get_song_filename(std::string rfid);
std::string get_rfid(MFRC522 &mfrc);

//Global variables
int run_rfid();
int run_normal();
int run_encoder_test();
void change_volume(int  percent);
void update_led(int pin, PinState  state, time_t time);

ma_sound playback;
ma_engine soundEngine;


void process_volume_encoder(PIN pinA, PIN pinB, int volumeIncrement);

int main(int argc, char * argv[]){

//	for(int i = 0 ; i<argc ; i++){
	
//	}
	
	if(argc>1){
		std::string str = argv[1];
		if(str=="--rfid"){
			return run_rfid();
		}else if(str=="--enc"){
			return run_encoder_test();
		}	
	}
		return run_normal();
	
}

int run_rfid(){
	MFRC522 mfrc;
	mfrc.PCD_Init();

	while(true){
/*	if(!mfrc.PICC_IsNewCardPresent()){
		std::cout<<"No card present"<<std::endl;
		continue;
	}
	if(!mfrc.PICC_ReadCardSerial()){
		std::cout<<"No Read serial"<<std::endl;
		continue;
	}
	std::string retval="";
	std::stringstream stream;
	for(byte i = 0; i < mfrc.uid.size; ++i){
		//retval+=char(mfrc.uid.uidByte[i]);
		if(mfrc.uid.uidByte[i] < 0x10){
			stream<<"0";
		}
		stream<<std::hex <<int(mfrc.uid.uidByte[i]);
	}

    retval = stream.str();*/
	std::string retval = get_rfid(mfrc);
	std::cout<<"\""<<retval<<"\""<<std::endl;
usleep(10000);
//	char a;
//std::cin>>a;
//	return 0;
	}
}

int run_normal(){
	MFRC522 mfrc;
	mfrc.PCD_Init();
	
	enum class ProgramCode{CONTINUE,END};
	ProgramCode executeCode = ProgramCode::CONTINUE;

	if(gpioInitialise()<0){
		std::cout<<"GPIO FAILED TO INITIALIZE!"<<std::endl;
	}
	std::cout<<"3"<<std::endl;
	gpioSetMode(PIN::PLAY,PI_INPUT);
	gpioSetPullUpDown(PIN::PLAY,PI_PUD_UP);
/*	gpioSetMode(PIN::VOL_A,PI_INPUT);//A
	gpioSetPullUpDown(PIN::VOL_A,PI_PUD_UP);
	gpioSetMode(PIN::VOL_B,PI_INPUT);//B
	gpioSetPullUpDown(PIN::VOL_B,PI_PUD_UP);*/

	
	int playButtonLastVal = 1;
	
	ma_result soundResult;
	soundResult = ma_engine_init(NULL, &soundEngine);
	if(soundResult!=MA_SUCCESS){
		std::cout<<"Failed to initialize audio engine!"<<std::endl;
		return -1;
	}

	time_t lastReadTime = 0;
	re_decoder dec(PIN::VOL_A,PIN::VOL_B,change_volume);

	PinState powerState=PinState::ON;
	PinState playState = PinState::FLASH1;
	while(executeCode!=ProgramCode::END){
		mfrc.PCD_Init();
		time_t now = time(NULL);
//		std::cout<<now<<" " << lastReadTime<<std::endl;
		if(true || now!=lastReadTime){
/*			byte atqa_answer[2];
      			byte atqa_size = 2;
      			mfrc.PICC_WakeupA(atqa_answer, &atqa_size);
*/
//			std::cout<<"hi"<<std::endl;
			lastReadTime=now;
			std::string rfid="";
			//std::cout<<"Enter File to play"<<std::endl;
	/*		std::getline(std::cin,a);
			std::cin.clear();
			std::cin.ignore(INT_MAX);*/

			rfid = get_rfid(mfrc);
		//	std::cout<<"RFID:"<<rfid<<std::endl;
			if(rfid==""){continue;}
			playState = PinState::ON;
			play_song(get_song_filename(rfid));
		}

		if(playButtonLastVal==1 && gpioRead(21)==0){
			if(ma_sound_is_playing(&playback)){
				ma_sound_stop(&playback);
				playState = PinState::FLASH1;
			}else{
				ma_sound_start(&playback);
				playState = PinState::ON;
			}
			std::cout<<"Play/Pause!"<<std::endl;
	//			mediaPlayer->pause();
		}
		playButtonLastVal=gpioRead(21);
		

		update_led(PIN::PLAY_LED,playState,now);
		update_led(PIN::STOP_LED,powerState,now);
			//wait a second
		
    // Print UID
    /*for(byte i = 0; i < mfrc.uid.size; ++i){
      if(mfrc.uid.uidByte[i] < 0x10){
	//printf(" 0");
	//printf("%X",mfrc.uid.uidByte[i]);
		std::cout<<" 0"<<std::hex<<mfrc.uid.uidByte[i];
      }
      else{
//	printf(" ");
	//printf("%X", mfrc.uid.uidByte[i]);
		std::cout<<" "<<std::hex<<mfrc.uid.uidByte[i];
      }
      
    }
    //printf("\n");
    std::cout<<std::endl;*/
//		process_volume_encoder(PIN::VOL_A, PIN::VOL_B, 5);
		usleep(1);
	}
	dec.re_cancel();
	gpioTerminate();
	ma_engine_uninit(&soundEngine);
/*	mediaPlayer->stop();
	
	delete playerInstance;
	delete media;
	delete mediaPlayer;*/
	return 0;
}


std::string get_song_filename(std::string rfid){
	std::ifstream file;
	file.open("/home/chris/projects/jukebox/register.csv",std::ios::in);
	if(file.is_open()){
		std::string line="",fname="";
		while(std::getline(file,line)){
			std::cout<<rfid<<" - " <<line<<std::endl;
			size_t comma = line.find(",");
			if(comma!=std::string::npos && comma!=0){
				std::string code = line.substr(0,comma);
				if(code==rfid){
					fname = line.substr(comma+1);
					break;
				}
			}
		}
		file.close();
		return fname;
	}
	if(rfid=="1"){return "batman.mp3";}
	if(rfid=="2"){return "Old MacDonald Had A Farm Nursery Rhymes Super Simple Songs.mp3";}
	return "";
}
std::string currentSong="";
void play_song(std::string fname){
	if(ma_sound_is_playing(&playback)){
		ma_sound_stop(&playback);
	}
	//Ignre song change if the song is already playing
	if(fname==currentSong){
		if(ma_sound_is_playing(&playback)){
			std::cout<<fname<<" is already playing!"<<std::endl;
			return;
		}
	}
	ma_sound_uninit(&playback);
	ma_result result;
	std::cout<<"PLAYING SONG:" <<fname<<std::endl;
	std::string fullpath = "/home/chris/Music/";
	fullpath+=fname;
	result = ma_sound_init_from_file(&soundEngine,fullpath.c_str(), 0, NULL, NULL, &playback);
	std::cout<<"RESULT:" <<result<<" | "<<MA_SUCCESS<<std::endl;
	if(result!=MA_SUCCESS){
		return;
	}
	ma_sound_start(&playback);
	//std::string cmd = "su chris && cvlc --play-and-exit \"/home/chris/Music/";
/*	system("pkill mpg123");
	std::string cmd = "mpg123 --no-control \"/home/chris/Music/";
	cmd+=fname;
	cmd+="\" &";
	std::cout<<cmd<<std::endl;
	system(cmd.c_str());*/
/*	if(media!=nullptr){
		delete media;
	}
	std::string path  = "/home/chris/Music/";
	path += fname;
	media = new VLC::Media(*playerInstance,path.data(),VLC::Media::FromPath);
	mediaPlayer->setMedia(*media);
	mediaPlayer->play();
*/
}
std::string get_rfid(MFRC522 & mfrc){
/*	char * cmd = "sudo ./jukebox --rfid";

	char buf[128] = {0};
	FILE *fp;
	if((fp=popen(cmd,"r")) == NULL){
		std::cout<<"Errr opening pipe!"<<std::endl;
		return "";
	}
	while(fgets(buf, 128, fp)!=NULL){
		return buf;
	}
	if(pclose(fp)){
		std::cout<<"Command not found or exited with error status"<<std::endl;
	}
	return "";*/
	if(!mfrc.PICC_IsNewCardPresent()){
//		std::cout<<"No card present"<<std::endl;
		return "";
	}
	if(!mfrc.PICC_ReadCardSerial()){
//		std::cout<<"No Read serial"<<std::endl;

		return "";
	}
	std::string retval="";
	std::stringstream stream;
	for(byte i = 0; i < mfrc.uid.size; ++i){
		//retval+=char(mfrc.uid.uidByte[i]);
		if(mfrc.uid.uidByte[i] < 0x10){
			stream<<"0";
		}
		stream<<std::hex <<int(mfrc.uid.uidByte[i]);
	}

    retval = stream.str();
	std::cout<<"\""<<retval<<"\""<<std::endl;
	return retval;
}

float volumeLevel = 0.5;
void change_volume(int  percent){
	std::cout<<"Change volume from "<<volumeLevel;
	if(percent>0){
		volumeLevel+=0.01;
	}else{
		volumeLevel-=0.01;
	}
	if(volumeLevel<0.0f){volumeLevel=0.0f;}
	if(volumeLevel>1.0f){volumeLevel=1.0f;}
	std::cout<<" to "<< volumeLevel << std::endl;
	ma_engine_set_volume(&soundEngine,volumeLevel);
	return;
/*	if(percent<0){
		system("./voldown");
		return;
	}else{
		system("./volup");
		return;
	}*/
	int i = std::abs(percent);
	std::stringstream sstream;
	sstream<<i;
	std::string pcode;
	sstream>>pcode;
	std::string code = "amixer set Master ";
	code+=pcode;
	code+="%";
	code+=(percent<0)?"-":"+";
//	std::cout<<code<<std::endl;
	system(code.c_str());
}

int run_encoder_test(){
	if(gpioInitialise()<0){
		std::cout<<"GPIO FAILED TO INITIALIZE!"<<std::endl;
		char a;
std::cin>>a;
	}
	std::cout<<"3"<<std::endl;
/*	gpioSetMode(PIN::VOL_A,PI_INPUT);//A
	gpioSetPullUpDown(PIN::VOL_A,PI_PUD_UP);
	gpioSetMode(PIN::VOL_B,PI_INPUT);//B
	gpioSetPullUpDown(PIN::VOL_B,PI_PUD_UP);
	char oldValue=0;*/
	re_decoder dec(PIN::VOL_A,PIN::VOL_B,change_volume);

	while(true){
/*		char value = (gpioRead(PIN::VOL_A)<<1) + gpioRead(PIN::VOL_B);
//		std::cout<<gpioRead(13)<<":"<<gpioRead(19)<<std::endl;
		if(value!=oldValue){
			std::cout<<"CHANGE"<<std::endl;
			//determine if chanel A or b changed
			std::cout<<"Old A:"<<int(oldValue & 2) << " New A:"<<int(value&2)<<std::endl;
			std::cout<<"Old B:"<<int(oldValue & 1)<< " New B:"<<int(value&1)<<std::endl;
			bool aChanged = false;
			if((value & 2) != (oldValue & 2) ){
				aChanged = true;
			}
			//determine if A and B now match or not
			bool signalMatch = false;
			char asignal = (value &2)>>1;
			if(asignal == (value & 1) ){
				signalMatch=true;
			}
			std::cout<<"aChanged:"<<std::string(aChanged?"1":"0")<<" Match:"<<std::string(signalMatch?"1":"0")<<std::endl;
			//A catches up to B 
			//if((aChanged && signalMatch) || (!achanged && !signalmatch) ){change_volume(-5);}
			if(aChanged==signalMatch){change_volume(-5);}
			//B catches up to A || A departs B
			//if((!aChanged && signalMatch) || (aChanged && !signalMatch) ){change_volume(5);}
			if(aChanged!=signalMatch){change_volume(5);}
			//A departs B
//			if(aChanged && !signalMatch){}
//			if(!aChanged && !signalMatch){}

			oldValue=value;
//			std::cout<<(int)value<<std::endl;
//			change_volume(5);
		}*/
//		process_volume_encoder(PIN::VOL_A,PIN::VOL_B,5);
	}
	dec.re_cancel();
	gpioTerminate();
	return 0;

}

int oldEncoderValue = 0;
void process_volume_encoder(PIN pinA, PIN pinB, int volumeInc=5){
	int value = (gpioRead(pinA)<<1) + gpioRead(pinB);
	if(value!=oldEncoderValue){
		bool aChanged = false;
		if((value & 2) != (oldEncoderValue & 2) ){
			aChanged = true;
		}
		//determine if A and B now match or not
		bool signalMatch = false;
		char asignal = (value &2)>>1;
		if(asignal == (value & 1) ){
			signalMatch=true;
		}
		//A catches up to B 
		//if((aChanged && signalMatch) || (!achanged && !signalmatch) ){change_volume(-5);}
		if(aChanged==signalMatch){change_volume(0-volumeInc);}
		//B catches up to A || A departs B
		//if((!aChanged && signalMatch) || (aChanged && !signalMatch) ){change_volume(5);}
		if(aChanged!=signalMatch){change_volume(volumeInc);}
		oldEncoderValue = value;
	}
	
}

void update_led(int pin, PinState  state, time_t time){
	switch(state){
		case PinState::OFF:
		gpioWrite(pin,0);
		break;
		case PinState::ON:
		gpioWrite(pin,1);
		break;
		case PinState::FLASH1:
		gpioWrite(pin,time%2);
		break;
		case PinState::FLASH2:
		gpioWrite(pin,(time%3)<2?1:0);
		break;
	}
}