#include <SPI.h>

#include <avr/wdt.h>
#include <Arduino.h>
#include <stdlib.h>
#include <SS_NRF24.h>
#include "CUE.h"
#include <SPI.h>

CUE cue;

/****************************MACROS***************************************/
#define UNDEBUG           
#define ZERO              0
#define CHIPENABLEPIN     8
#define SCK_PIN           13
#define MISO_PIN          12
#define MOSI_PIN          11
#define SPICHIPSELECTPIN  10
#define LED               6
/********chip select pins**********/
#define CE_PINOUT     pinMode(CHIPENABLEPIN, OUTPUT);
#define SPI_CS        pinMode(SPICHIPSELECTPIN, OUTPUT);
      
#define SPI_SCK       pinMode(SCK_PIN,OUTPUT);
#define SPI_MISO      pinMode(MISO_PIN,INPUT);
#define SPI_MOSI      pinMode(MOSI_PIN,OUTPUT);


#define CE_LOW        digitalWrite(CHIPENABLEPIN, LOW);
#define CE_HIGH       digitalWrite(CHIPENABLEPIN, HIGH);
#define SPI_CS_LOW    digitalWrite(SPICHIPSELECTPIN, LOW);
#define SPI_CS_HIGH   digitalWrite(SPICHIPSELECTPIN, HIGH);
/***********************nRF24L01+ macros****************************/
/*******commands********/
#define READ_REG        0x00  // Define read command to register
#define WRITE_REG       0x20  // Define write command to register
#define RD_RX_PLOAD     0x61  // Define RX payload register address
#define WR_TX_PLOAD     0xA0  // Define TX payload register address
#define FLUSH_TX        0xE1  // Define flush TX register command
#define FLUSH_RX        0xE2  // Define flush RX register command
#define REUSE_TX_PL     0xE3  // Define reuse TX payload register command
#define NOP             0xFF  // Define No Operation, might be used to read status register
/*******registers(addresses)*********/
#define CONFIG          0x00  // 'Config' register address
#define EN_AA           0x01  // 'Enable Auto Acknowledgment' register address
#define EN_RXADDR       0x02  // 'Enabled RX addresses' register address
#define SETUP_AW        0x03  // 'Setup address width' register address
#define SETUP_RETR      0x04  // 'Setup Auto. Retrans' register address
#define RF_CH           0x05  // 'RF channel' register address
#define RF_SETUP        0x06  // 'RF setup' register address
#define STATUS          0x07  // 'Status' register address
#define OBSERVE_TX      0x08  // 'Observe TX' register address
#define CD              0x09  // 'Carrier Detect' register address
#define RX_ADDR_P0      0x0A  // 'RX address pipe0' register address
#define RX_ADDR_P1      0x0B  // 'RX address pipe1' register address
#define RX_ADDR_P2      0x0C  // 'RX address pipe2' register address
#define RX_ADDR_P3      0x0D  // 'RX address pipe3' register address
#define RX_ADDR_P4      0x0E  // 'RX address pipe4' register address
#define RX_ADDR_P5      0x0F  // 'RX address pipe5' register address
#define TX_ADDR         0x10  // 'TX address' register address
#define RX_PW_P0        0x11  // 'RX payload width, pipe0' register address
#define RX_PW_P1        0x12  // 'RX payload width, pipe1' register address
#define RX_PW_P2        0x13  // 'RX payload width, pipe2' register address
#define RX_PW_P3        0x14  // 'RX payload width, pipe3' register address
#define RX_PW_P4        0x15  // 'RX payload width, pipe4' register address
#define RX_PW_P5        0x16  // 'RX payload width, pipe5' register address
#define FIFO_STATUS     0x17  // 'FIFO Status Register' register address
#define MAX_RT          0x10  // Max #of TX retrans interrupt
#define TX_DS           0x20  // TX data sent interrupt
#define RX_DR           0x40  // RX data received
/****************userdefined nRF macros**************/
#define TX_ADR_WIDTH    5     // 5 bytes TX(RX) address width
#define TX_PLOAD_WIDTH  32    // 32 bytes TX payload
#define STATUS_CLEAR    0x70  // To clear the status
/***************************TYPEDEFS***************************************/
typedef unsigned char U_INT8;
typedef unsigned int U_INT16;

/********************************/
const int LED_PIN = 6;
const int MAX_PHONE_NUMBERS = 3;
const int PHONE_NUMBER_LENGTH = 13;
char phone[MAX_PHONE_NUMBERS][PHONE_NUMBER_LENGTH] = {""};
const int SIZE_OF_REPLY = 40;
unsigned long timeCurrent = 0;
unsigned long timeOld = 0;
unsigned long timeOlder = 0;
unsigned long plugThreshTime = 0;
unsigned long backupTime = 0;
const unsigned long ONE_MINUTES_MILLIS = 60000;
int checkMessageInterval = 0;
/********************************/


/***************************GLOBAL VARIABLES*******************************/
U_INT8 TX_ADDRESS[TX_ADR_WIDTH]={0xE7,0xE7,0xE7,0xE7,0xE7}; // Define a static TX address
U_INT8 spi_flag=0;

unsigned long toInteger(char* str);
void spi_init(void);
void nrf_init_rx(void);
U_INT8 nrf_transmit(U_INT8* ptr);
U_INT8 nrf_receive(U_INT16 timeout,U_INT8* ptr);
void TX_mode(void);
void nrf24_tx_address(U_INT8* adr);
void nrf24_powerdown(void);
void nrf24_powerUpTx(void);
U_INT8 check_status_Tx(void);
U_INT8 check_status_Rx(void);
void pulse_CE_tx(void);
void RX_mode(void);
void nrf24_rx_address(U_INT8* adr);
void nrf24_powerUpRx(void);
void writeRegister(U_INT8 thisRegister, U_INT8 thisValue);
U_INT8 readRegister(U_INT8 thisRegister);
U_INT8 SPI_Read_Buf(U_INT8 reg,U_INT8* pBuf,U_INT8 bytes);
U_INT8 SPI_Write_Buf(U_INT8 reg,U_INT8* pBuf,U_INT8 bytes);
U_INT8 spi_transfer(U_INT8 data);
void flush_TX(void);
void flush_RX(void);
byte sendRFUptoAck(int iterationsSend, unsigned long h, int s, int b, int v, byte isExpectingAck);
byte recvRFPacket(int timeout, unsigned long *h, int *s, int *b, int *v);

unsigned long toInteger(char* str)
{
	unsigned long val = 0;
	int i=0;
	val = 0;
	for(i=0; i<strlen(str);i++)
	{
	  val = val*10;
	  val += str[i]-48;
	}
	
	return val;
}

/*SCK -> 62500Hz
 *Interrupt -> disabled 
 *Master mode is enabled
 *MSB of data is transmitted first
 *and put RF module into RX mode*/
void spi_init()
{
  /*Pinouts*/
  CE_PINOUT;
  CE_LOW;
  
  SPI_CS; 
  SPI_CS_HIGH;
  
  SPI_SCK;
  SPI_MISO;
  SPI_MOSI;
    
  SPCR = 0xD3;
  SPSR = 0x00;
  
  delay(1);
  
  nrf24_powerdown();
  nrf_init_rx();  
}

void nrf_init_rx()
{
  RX_mode();
  nrf24_rx_address(TX_ADDRESS);
  nrf24_powerUpRx();
  CE_HIGH;
}

U_INT8 nrf_transmit(U_INT8* ptr)
{
  U_INT8 tx_status=0;
  #ifdef DEBUG
  Serial.println("TX mode");
  #endif
  
  nrf24_powerdown();
  delay(3);
  TX_mode();
  nrf24_tx_address(TX_ADDRESS);
  SPI_Write_Buf(WR_TX_PLOAD,ptr,TX_PLOAD_WIDTH);
  nrf24_powerUpTx();
  pulse_CE_tx();// >10us
  
  U_INT16 tx_timeout = 0;
  while(tx_timeout++<1000)
  {
    delay(1);
    if(check_status_Tx() == 1) 
    {     
      tx_status = 1;
      break;
    }
  }
  /*************Initailize to Reception mode**************/
  nrf24_powerdown();
  delay(3);
  nrf_init_rx();
  #ifdef DEBUG
  Serial.println("RX mode");
  #endif      
  /***************************/        
  return(tx_status);  
}

U_INT8 nrf_receive(U_INT16 timeout,U_INT8* ptr)
{
  U_INT8 rx_status=0;
  U_INT16 count=0;
  while(count++<timeout)
  {
    if(check_status_Rx() == 1) 
    {
      SPI_Read_Buf(RD_RX_PLOAD,ptr,TX_PLOAD_WIDTH);
	  //#ifdef DEBUG
      Serial.println((const char*)ptr);
      digitalWrite(LED, HIGH);
      delay(100);
      digitalWrite(LED, LOW);
      delay(50);      
      digitalWrite(LED, HIGH);
      delay(100);
      digitalWrite(LED, LOW);
	  //#endif
      rx_status = 1;      
      return(rx_status);  
    }
	wdt_reset();
  }
  #ifdef DEBUG
  if(count>=timeout)
  {
    Serial.println("timeout"); 
    Serial.println("status: "); 
    Serial.println(readRegister(READ_REG + STATUS),HEX);
    Serial.println("config: "); 
    Serial.println(readRegister(READ_REG + CONFIG),HEX);
  }
  #endif
  return(rx_status);   
}

/*Transmission mode nRF*/
void TX_mode(void)
{
  /*standby-1 mode*/
  CE_LOW;
  /*Enable auto ACK data pipe 0*/
  writeRegister(WRITE_REG + EN_AA, 0x00);
  /*Enable RX addr of data pipe 0*/
  writeRegister(WRITE_REG + EN_RXADDR, 0x02);
  /*TX/RX address width is 5bytes(common for all data pipes)*/
  writeRegister(WRITE_REG + SETUP_AW, 0x03);
  /*Auto retransmit delay is 500us
   *Auto retransmit count is 10 on fail of AA*/
  writeRegister(WRITE_REG + SETUP_RETR, 0x00);
  /*Select the RF channel number
   *range of channel is 2^7 */
  writeRegister(WRITE_REG + RF_CH, 120); 
  /*Data rate is 250kbps
   *Output power is 0dbm(1mW)*/
  writeRegister(WRITE_REG + RF_SETUP, 0x23);
  /*flushing TX buffer*/
  flush_TX();
}

void nrf24_tx_address(U_INT8* adr)
{
  /*PTX addr(transmit device only)(i.e, clk the addr of receiving node)
   *and also set RX_ADDR_P0 equal to this addr to handle automatic ACK 
   *if its PTX device*/
  SPI_Write_Buf(WRITE_REG + TX_ADDR, adr, TX_ADR_WIDTH);
  /*Set the receive addr data pipe 0:::for Auto.Ack*/
  SPI_Write_Buf(WRITE_REG + RX_ADDR_P1, adr, TX_ADR_WIDTH);
}

void nrf24_powerdown()
{
  /*power down NRF*/
  U_INT8 value = readRegister(READ_REG + CONFIG);
  value &= 0xFD;
  writeRegister(WRITE_REG + CONFIG, value); 
}

void nrf24_powerUpTx()
{
  /*clear the status*/
  writeRegister(WRITE_REG+STATUS, STATUS_CLEAR);           
  /*powerUP bit high >> standby-1 mode
   *Enable CRC
   *Enable CRC 2 byte
   *Enable PTX*/
  writeRegister(WRITE_REG + CONFIG, 0x7E);
  /*Start up time 1.5ms*/
  delay(5);
}

U_INT8 check_status_Tx()
{
  U_INT16 i=0;
  U_INT8 tx_status=0;  
  /*check for status*/
  if((readRegister(READ_REG + STATUS) & TX_DS) == TX_DS)
  {
    /*clear the status*/
    writeRegister(WRITE_REG+STATUS, STATUS_CLEAR); 
    #ifdef DEBUG
    Serial.println("TX done");
    #endif 
    tx_status = 1; 
  }
  return tx_status;
}

U_INT8 check_status_Rx()
{
  U_INT16 rx_status=0,i=0;   
  if((readRegister(READ_REG + STATUS) & RX_DR) == RX_DR)
  {
    /*clear the status*/
    writeRegister(WRITE_REG+STATUS, STATUS_CLEAR); 
    #ifdef DEBUG
    Serial.println("RX done");
    #endif 
    rx_status = 1;     
  }
  return rx_status;
}

void pulse_CE_tx()
{
  U_INT8 i=0;
  
  CE_HIGH;
  for(i=0;i<150;i++);
  CE_LOW;
}

/*Reception mode nRF*/
void RX_mode(void)
{
  /*standby-1 mode*/
  CE_LOW;
  /*Enable auto ACK data pipe 0*/
  writeRegister(WRITE_REG + EN_AA, 0x00);
  /*Enable RX addr of data pipe 0*/
  writeRegister(WRITE_REG + EN_RXADDR, 0x02);
   /*TX/RX address width is 5bytes(common for all data pipes)*/
  writeRegister(WRITE_REG + SETUP_AW, 0x03);
  /*Select the RF channel number
   *range of channel is 2^7 */  
  writeRegister(WRITE_REG + RF_CH, 120);  
  /*Data rate is 250kbps
   *Output power is 0dbm(1mW)*/  
  writeRegister(WRITE_REG + RF_SETUP, 0x23);
  /*Number of bytes in RX payload in data pipe 0*/
  writeRegister(WRITE_REG + RX_PW_P1, TX_PLOAD_WIDTH);
}

void nrf24_rx_address(U_INT8* adr)
{
  /*Set the receive addr data pipe 0*/  
  SPI_Write_Buf(WRITE_REG + RX_ADDR_P1, adr, TX_ADR_WIDTH);
}

void nrf24_powerUpRx()
{
  /*clear the status*/
  writeRegister(WRITE_REG+STATUS, STATUS_CLEAR);           
  /*powerUP bit high >> standby-1 mode
   *Enable CRC
   *Enable CRC 2 byte
   *Enable PTX*/
  writeRegister(WRITE_REG + CONFIG, 0x7F);
  /*Start up time 1.5ms*/
  delay(5);  
}

void writeRegister(U_INT8 thisRegister, U_INT8 thisValue)
{
  /*select the chip*/
  SPI_CS_LOW;
  /*write addr*/
  spi_transfer(thisRegister); 
  /*write data to addr written*/
  spi_transfer(thisValue);  //Send value to record into register
  /*Deselect the chip*/
  SPI_CS_HIGH;  
}

/**********************still function is incomplete****************/
U_INT8 readRegister(U_INT8 thisRegister)
{
  U_INT8 data = 0,i = 0;
  /*select the chip*/
  SPI_CS_LOW;
  /*write addr*/
  spi_transfer(thisRegister);  
  /*write data to addr written*/
  data = spi_transfer(ZERO);  //Send value to record into register
  /*Deselect the chip*/
  SPI_CS_HIGH; 
  
  return data;
}

U_INT8 SPI_Read_Buf(U_INT8 reg,U_INT8* pBuf,U_INT8 bytes)
{
  U_INT8 dummy = 0, i = 0;
  /*select the chip*/
  SPI_CS_LOW;
  /*Select register to write to and read status byte*/
  dummy = spi_transfer(reg);           
  /*Perform SPI_RW to read byte from nRF24L01*/
  for(i=0;i<bytes;i++)
    pBuf[i] = spi_transfer(ZERO);    
  /*Deselect the chip*/
  SPI_CS_HIGH; 
  return(dummy);
}

U_INT8 SPI_Write_Buf(U_INT8 reg,U_INT8* pBuf,U_INT8 bytes)
{
  U_INT8 dummy = 0, i = 0;
  /*select the chip*/
  SPI_CS_LOW;
  /*write address*/
  dummy = spi_transfer(reg);
  /*write all byte in buffer(*pBuf)*/           
  for(i=0; i<bytes; i++) 
    dummy = spi_transfer(*pBuf++);
  /*Deselect the chip*/
  SPI_CS_HIGH;  
  return(dummy);
}

U_INT8 spi_transfer(U_INT8 data)
{
  /*Write the byte*/
  SPDR = data;
  /*Wait for SPIF set*/
  while(spi_flag == 0)
  {
    delay(10); 
	wdt_reset();	
  }
  spi_flag = 0;
  /*read dummy byte*/
  data = SPDR;
  
  return(data);
}
/*SPI ISR*/
ISR(SPI_STC_vect)
{
  spi_flag = 0xff;
}

void flush_TX() 
{
  /*command*/
  spi_transfer(FLUSH_TX);   
}
void flush_RX()
{
  /*command*/
  spi_transfer(FLUSH_RX);   
}