#include <IRremote.h>
#include <EEPROM.h> 
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>    // Adafruit 0.96" OLED Library

#define oledAddress 0x3c        // Banggood oleds I2C address differs from Adafruit oleds.

int SDIO = A4;                  // I2C bus for OLED Display.
int SCLK = A5;

Adafruit_SSD1306 oled(12);       // Initialise Adafruit library

int oledVcc = A3;                // 5v supply for OLED


int RECV_PIN = 2;                // Infra Red input to ATmega328

IRrecv irrecv(RECV_PIN);         // Initialise IR library

decode_results results;

long RemoteVolUp;                // My remote's code = 0xe0e0e01f;
long RemoteVolDown;              // = 0xe0e0d02f;
long RemoteMute;                 // = 0xe0e0f00f; 

long lastCode = 0;
unsigned long timer = 0;
unsigned long timerLed = 0;

unsigned long volumeTimer = 0;

bool muteLedOn = true;
bool volumeTimerOn = false;


int PWM = 9;                   // Frequency increased to 31372.55 Hz in setup.

int learn = 8;

int VolUp = 7;                 // Volume Up button.
int VolDown = 6;               // Volume down button

int mutedLed = 5;              // Flash LED when sound is muted


int Volume = 255;
int volumeOffset = 40;         // 0 to 39 is virtually silent so make range 40 - 100.
bool isMuted = false;

void setup (void) {
TCCR1B = (TCCR1B & 0b11111000) | 0x01;     // Set PWM frequency on pins 9 & 10 to 31372.55 Hz

  Serial.begin(9600);

 pinMode(oledVcc, OUTPUT);                 // 5V supply to OLED display
 pinMode(mutedLed, OUTPUT);                // Flash an LED while FM62429 volume is muted.

 pinMode(VolDown, INPUT_PULLUP);           // Push buttons for Volume Up, Volume Down and
 pinMode(VolUp, INPUT_PULLUP);
 pinMode(learn, INPUT_PULLUP);             // Learn remote codes.

 irrecv.enableIRIn();                      // Start the receiver

 RemoteVolUp = EEPROMReadlong(1);          // Read remote codes that have previously
 RemoteVolDown = EEPROMReadlong(5);        // been saved in EEPROM. Each code is
 RemoteMute = EEPROMReadlong(9);           // 4 bytes in length.
 
 if (EEPROM.read(0) <= 255) {              // Read last volume setting from EEPROM.
  Volume = EEPROM.read(0);
 }
 analogWrite(PWM, Volume);                        // Set  volume .
}

void startOled() {                                 // OLED causes some interference to
  digitalWrite(oledVcc, HIGH);                     // the audio so it is only powered
  oled.begin(SSD1306_SWITCHCAPVCC, oledAddress);   // up and initialised when required.
  delay(50);
  oled.clearDisplay();   
  oled.setTextColor(WHITE);  
}

void learnRemote() {                               // Routine to receive remote codes for
  startOled();                                     // Volume Up, Volume Down & Mute and
  oled.setTextSize(1);                             // save them in EEPROM.
  oled.setCursor(40,0);
  oled.print("Learn");
  oled.setCursor(5,8);
  oled.print("Vol + ");
  oled.display();
  results.value = 0;
  while (results.value == 0) { 
    if (irrecv.decode(&results)) {
    //Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value
    delay(100);
    }
  }  
  RemoteVolUp = results.value;
  oled.print("OK");
  oled.setCursor(5, 16);
  oled.print("Vol - ");
  oled.display();
  results.value = 0;
  while ((results.value == 0) || (results.value == RemoteVolUp)) { 
    if (irrecv.decode(&results)) {
    // Serial.println(results.value, HEX);
      irrecv.resume(); // Receive the next value
      delay(100);
    }   
  }
  RemoteVolDown = results.value;  
  oled.print("OK");
  oled.setCursor(5, 24);
  oled.print("Mute ");
  oled.display();
  results.value = 0;
  while ((results.value == 0) || (results.value == RemoteVolDown)) { 
    if (irrecv.decode(&results)) {
      //Serial.println(results.value, HEX);
      irrecv.resume(); // Receive the next value
      delay(100);
    } 
  }
  RemoteMute = results.value; 
  oled.print(" OK.. ");
  oled.print("Done ");
  oled.display();
     
  if (EEPROMReadlong(1) != RemoteVolUp) EEPROMWritelong(1, RemoteVolUp);
  if (EEPROMReadlong(5) != RemoteVolDown) EEPROMWritelong(5, RemoteVolDown);
  if (EEPROMReadlong(9) != RemoteMute) EEPROMWritelong(9, RemoteMute);
  delay(3000);
  digitalWrite(oledVcc, LOW);
  lastCode = RemoteMute;
  isMuted = false;
  analogWrite(PWM, Volume); 
}


void loop (void) {

  if (digitalRead(learn) == LOW) {
    while (digitalRead(learn) == LOW);
    learnRemote();
    delay(100);
  }

  results.value = 0;

  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value
    delay(80);
  }   
  
 if ((digitalRead(VolUp) == LOW) || (results.value == RemoteVolUp)) {
  if (Volume < 255) {
    Volume++;
    analogWrite(PWM, Volume);
    isMuted = false;
    lastCode = results.value;
  }
  showVolume();
  if (digitalRead(VolUp) == LOW) delay(100);
 }
 
 if ((digitalRead(VolDown) == LOW) || (results.value == RemoteVolDown)) {
  if (Volume > volumeOffset) {
    Volume--;
    analogWrite(PWM, Volume);
    isMuted = false;
    lastCode = results.value;
  }
  showVolume();
  if (digitalRead(VolDown) == LOW) delay(100);
 }

 if ((results.value == RemoteMute) && (lastCode != RemoteMute)){
     timer = millis();                                   
     if (!isMuted) {                                      // The same IR code is used to mute and
      analogWrite(PWM, 0);
                                                          // unmute. Remote may send the code
      isMuted = true;                                     // more than once for one button-
      timerLed = millis();                                // press so ignore 2nd and subsequent
     } else {                                             // codes.  Start a timer so that the
      analogWrite(PWM, Volume);                           // 'ignore' flag can be reset one
      showVolume();                                       // second after no more 'mute' codes
      isMuted = false;                                    // are received.
     }                                                    // Next time the code is received must
     lastCode = results.value;                            // mean 'toggle' the mute setting.
  }

  if (millis() - timer > 1000) {                          // Reset the 'ignore mute code' flag.
   lastCode = 0;
  }

  if (millis() - timerLed > 250) {                          // Set up flashing output for
    muteLedOn = !muteLedOn;                                 // 'muted' LED
    timerLed = millis();
  }

  digitalWrite(mutedLed, (muteLedOn && isMuted));            // Flash 'muted' LED if muted.

  if ((millis() - volumeTimer > 1500) && volumeTimerOn) {    // Turn off OLED display after
    volumeTimerOn = false;                                   // 1.5 seconds and write new
    digitalWrite(oledVcc, LOW);                              // volume setting to EEPROM.
    if (EEPROM.read(0) != Volume) {
       EEPROM.write(0, Volume);
    }
  }
 
}

void showVolume() {
  if (!volumeTimerOn) {                                     // If OLED is not already powered,
    startOled();                                            // power it up.
    oled.setTextSize(3);
  }
  oled.clearDisplay();
  oled.setCursor(40,8);
  oled.print(map(Volume, volumeOffset, 255, 0, 100));       // 40 to 255 for Pre-amp IC = 0 to 100 for display
  oled.display();

  volumeTimerOn = true;                                     // Flag that the display timer is running
  volumeTimer = millis();                                   // Start the display timer.
}



void EEPROMWritelong(int address, long value) {
    //Decomposition from a long to 4 bytes by using bitshift.
      //One = Most significant -> Four = Least significant byte
      byte four = (value & 0xFF);
      byte three = ((value >> 8) & 0xFF);
      byte two = ((value >> 16) & 0xFF);
      byte one = ((value >> 24) & 0xFF);

      //Write the 4 bytes into the eeprom memory.
      EEPROM.write(address, four);
      EEPROM.write(address + 1, three);
      EEPROM.write(address + 2, two);
      EEPROM.write(address + 3, one);
}

long EEPROMReadlong(long address)  {
      //Read the 4 bytes from the eeprom memory.
      long four = EEPROM.read(address);
      long three = EEPROM.read(address + 1);
      long two = EEPROM.read(address + 2);
      long one = EEPROM.read(address + 3);

      //Return the recomposed long by using bitshift.
      return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}