#include <avr/sleep.h>
#include <avr/power.h> 
//#include <avr/interrupt.h>
//#include <avr/io.h>
#include <util/delay.h>

#define F_CPU 1200000UL    
#define PIN_TX (1<<PB3) // PB3 pin, goes to transmitter data pin

#define nTransmitterPin 0
#define nProtocol 1

#define nPulseLength 1 // 270 //pulse lenght calibrate untill the "real"
//lenght are around 350
#define nRepeatTransmit 5 //retransmitts

// const int buttonPin = 0;
const int ledPin = 4; //1;

void setup() {
  DDRB  = 0b000001; // all but PB0 INPUT, want to use PB0 ...
  PORTB = 0b000000; // all LOW
  
  // pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);

  digitalWrite(ledPin, LOW);

  DDRB |= PIN_TX; // Set output direction on PIN_TX
}

void loop() {
  //sleep();                      // sleep function called here

  digitalWrite(ledPin, HIGH);
  delay(10);
  digitalWrite(ledPin, LOW);
  //  delay(1000);

  for (int i = 0; i < nRepeatTransmit; i++) {
    send("1011101000110101");
    delay(100);
  }
  // 4s * n
  for (int i = 0; i < 3; i++) {
    sleepNow();
  }
}


void sleepNow() {
  {
//    BODCR |= (1<<BODS)|(1<<BODSE);       //Disable Brown Out Detector Control Register
    ACSR |= (1<<ACD);   //Analog comparator off
    ACSR = ADMUX = ADCSRA = 0;
  }

  WDTCR |= (1<<WDP3) ;      //Watchdog set for about 4 seconds
 
  // Enable watchdog timer interrupts
  WDTCR |= (1<<WDTIE);
  sei(); // Enable global interrupts
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_mode();
  sleep_disable();
}

/*   */

/**
 * Sends a "0" Bit
 *                       _   
 * Waveform Protocol 1: | |___
 *                       _ 
 * Waveform Protocol 2: | |__
 */
void send0() {
    if (nProtocol == 1){
        transmit(1,3);
    }
    else if (nProtocol == 2) {
        transmit(1,2);
    }
    else if (nProtocol == 3) {
        transmit(4,11);
    }
}

/**
 * Sends a "1" Bit
 *                       ___ 
 * Waveform Protocol 1: |   |_
 *                       __ 
 * Waveform Protocol 2: |  |_
 */
void send1() {
      if (nProtocol == 1){
        transmit(3,1);
    }
    else if (nProtocol == 2) {
        transmit(2,1);
    }
    else if (nProtocol == 3) {
        transmit(9,6);
    }
}

/**
 * Sends a Tri-State "0" Bit
 *            _     _
 * Waveform: | |___| |___
 */
void sendT0() {
  transmit(1,3);
  transmit(1,3);
}

/**
 * Sends a Tri-State "1" Bit
 *            ___   ___
 * Waveform: |   |_|   |_
 */
void sendT1() {
  transmit(3,1);
  transmit(3,1);
}

/**
 * Sends a Tri-State "F" Bit
 *            _     ___
 * Waveform: | |___|   |_
 */
void sendTF() {
  transmit(1,3);
  transmit(3,1);
}

/**
 * Sends a "Sync" Bit
 *                       _
 * Waveform Protocol 1: | |_______________________________
 *                       _
 * Waveform Protocol 2: | |__________
 */
void sendSync() {

    if (nProtocol == 1){
        transmit(1,31);
    }
    else if (nProtocol == 2) {
        transmit(1,10);
    }
    else if (nProtocol == 3) {
        transmit(1,71);
    }
}

void sendTriState(char* sCodeWord) {
  for (int nRepeat=0; nRepeat<nRepeatTransmit; nRepeat++) {
    int i = 0;
    while (sCodeWord[i] != '\0') {
      switch(sCodeWord[i]) {
        case '0':
          sendT0();
        break;
        case 'F':
          sendTF();
        break;
        case '1':
          sendT1();
        break;
      }
      i++;
    }
    sendSync();   
  }
}

void transmit(int nHighPulses, int nLowPulses) {
  digitalWrite(nTransmitterPin, HIGH);
  _delay_ms(nPulseLength * nHighPulses);
  digitalWrite(nTransmitterPin, LOW);
  _delay_ms(nPulseLength * nLowPulses);
}

char* dec2binWzerofill(unsigned long Dec, unsigned int bitLength){
    return dec2binWcharfill(Dec, bitLength, '0');
}

char* dec2binWcharfill(unsigned long Dec, unsigned int bitLength, char fill){
  static char bin[64];
  unsigned int i=0;

  while (Dec > 0) {
    bin[32+i++] = ((Dec & 1) > 0) ? '1' : fill;
    Dec = Dec >> 1;
  }

  for (unsigned int j = 0; j< bitLength; j++) {
    if (j >= bitLength - i) {
      bin[j] = bin[ 31 + i - (j - (bitLength - i)) ];
    }else {
      bin[j] = fill;
    }
  }
  bin[bitLength] = '\0';
 
  return bin;
}

void send(char* sCodeWord) {
  for (int nRepeat=0; nRepeat<nRepeatTransmit; nRepeat++) {
    int i = 0;
    while (sCodeWord[i] != '\0') {
      switch(sCodeWord[i]) {
        case '0':
          send0();
        break;
        case '1':
          send1();
        break;
      }
      i++;
    }
    sendSync();
  }
}