#include <SparkFun_APDS9960.h>
#include <Wire.h>
#include <I2Cdev.h>
#include <MPU6050.h>
#include <TimerOne.h>
/**********************************************************/
/* 名   称：NRF24L01+无线USB通信模块程序                  */
/* 功   能：发送接收测试程序                              */
/*          格式：首位是个数，后面跟要发送的数据          */ 
/*                例如：发送5个字节 11 22 33 44 55(16进制)*/
/*                电脑串口发送：1122334455                */
/*                模块实际发送：051122334455              */    
/*Arduino Pin  APDS-9960 Board  Function
 
 3.3V         VCC              Power
 GND          GND              Ground
 A4           SDA              I2C Data
 A5           SCL              I2C Clock
 2            INT              Interrupt                */
/**********************************************************/

#define APDS9960_INT    2
#define uchar unsigned char
#define uint  unsigned int

/**********  NRF24L01寄存器操作命令  ***********/
#define READ_REG        0x00  //读配置寄存器,低5位为寄存器地址
#define WRITE_REG       0x20  //写配置寄存器,低5位为寄存器地址
#define RD_RX_PLOAD     0x61  //读RX有效数据,1~32字节
#define WR_TX_PLOAD     0xA0  //写TX有效数据,1~32字节
#define FLUSH_TX        0xE1  //清除TX FIFO寄存器.发射模式下用
#define FLUSH_RX        0xE2  //清除RX FIFO寄存器.接收模式下用
#define REUSE_TX_PL     0xE3  //重新使用上一包数据,CE为高,数据包被不断发送.
#define NOP             0xFF  //空操作,可以用来读状态寄存器	 
/**********  NRF24L01寄存器地址   *************/
#define CONFIG          0x00  //配置寄存器地址                             
#define EN_AA           0x01  //使能自动应答功能 
#define EN_RXADDR       0x02  //接收地址允许
#define SETUP_AW        0x03  //设置地址宽度(所有数据通道)
#define SETUP_RETR      0x04  //建立自动重发
#define RF_CH           0x05  //RF通道
#define RF_SETUP        0x06  //RF寄存器
#define STATUS          0x07  //状态寄存器
#define OBSERVE_TX      0x08  // 发送检测寄存器
#define CD              0x09  // 载波检测寄存器
#define RX_ADDR_P0      0x0A  // 数据通道0接收地址
#define RX_ADDR_P1      0x0B  // 数据通道1接收地址
#define RX_ADDR_P2      0x0C  // 数据通道2接收地址
#define RX_ADDR_P3      0x0D  // 数据通道3接收地址
#define RX_ADDR_P4      0x0E  // 数据通道4接收地址
#define RX_ADDR_P5      0x0F  // 数据通道5接收地址
#define TX_ADDR         0x10  // 发送地址寄存器
#define RX_PW_P0        0x11  // 接收数据通道0有效数据宽度(1~32字节) 
#define RX_PW_P1        0x12  // 接收数据通道1有效数据宽度(1~32字节) 
#define RX_PW_P2        0x13  // 接收数据通道2有效数据宽度(1~32字节) 
#define RX_PW_P3        0x14  // 接收数据通道3有效数据宽度(1~32字节) 
#define RX_PW_P4        0x15  // 接收数据通道4有效数据宽度(1~32字节)
#define RX_PW_P5        0x16  // 接收数据通道5有效数据宽度(1~32字节)
#define FIFO_STATUS     0x17  // FIFO状态寄存器
/*————————————————————————————————————————————————————————————————————*/

/******   STATUS寄存器bit位定义      *******/
#define MAX_TX  	0x10  	  //达到最大发送次数中断
#define TX_OK   	0x20  	  //TX发送完成中断
#define RX_OK   	0x40  	  //接收到数据中断
/*——————————————————————————————————————————————————*/

/*********     24L01发送接收数据宽度定义	  ***********/
#define TX_ADR_WIDTH    5     //5字节地址宽度
#define RX_ADR_WIDTH    5     //5字节地址宽度
#define TX_PLOAD_WIDTH  32    //32字节有效数据宽度
#define RX_PLOAD_WIDTH  32    //32字节有效数据宽度

const uchar TX_ADDRESS[TX_ADR_WIDTH]={0xFF,0xFF,0xFF,0xFF,0xFF}; //发送地址
const uchar RX_ADDRESS[RX_ADR_WIDTH]={0xFF,0xFF,0xFF,0xFF,0xFF}; //发送地址

uchar rece_buf[32];//jie shou fa song shu zu
MPU6050 accelgyro;
SparkFun_APDS9960 apds = SparkFun_APDS9960();
int isr_flag = 0;


void setup()
{
   
 //Serial.begin(9600);  
  Wire.begin();


    accelgyro.initialize();
   
   //SparkFun_APDS9960();
   
    pinMode(12,OUTPUT);//CE
    pinMode(3,OUTPUT);//CSN
    pinMode(4,INPUT);//MISO
    pinMode(5,OUTPUT);//MOSI
    pinMode(6,OUTPUT);//SCK
    pinMode(7,INPUT);//IRQ
    //pinMode(12,INPUT);//fa song jian
   // pinMode(13,OUTPUT);
   
   //SparkFun_APDS9960();    
   pinMode(8,INPUT);//
    pinMode(9,INPUT);//
    pinMode(10,INPUT);//
    pinMode(11,INPUT);//
    pinMode(A1,INPUT);//
    pinMode(A0,INPUT);//
    pinMode(2, INPUT);
//detachInterrupt(0);
     //attachInterrupt(0, interruptRoutine, FALLING);
     attachInterrupt(0, interruptRoutine, CHANGE);
   // attachInterrupt(digitalPinToInterrupt(APDS9960_INT), interruptRoutine, CHANGE);
 
   
}

void delay_us(uchar num)
{
	uchar i; 
	for(i=0;i>num;i++)
 	;;;//_nop_();
}
void delay_150us()
{
	uint i;

	for(i=0;i>150;i++);
}
void delay1(uint t)
{
	uchar k;
	while(t--)
	for(k=0;k<200;k++);
}
/***************************************************************/

/*******************************************************************/
uchar SPI_RW(uchar byte)
{
	uchar bit_ctr;
	for(bit_ctr=0;bit_ctr<8;bit_ctr++)  // 输出8位
	{
		//MOSI=(byte&0x80); 			
                digitalWrite(5,(byte&0x80));// MSB TO MOSI
		byte=(byte<<1);	
                digitalWrite(6,HIGH);//sck				// shift next bit to MSB
		//NRF_SCK=1;
		byte|=digitalRead(4);	        		// capture current MISO bit
		 digitalWrite(6,LOW);//sck
	}
	return byte;
}

/*********************************************/
/* 函数功能：给24L01的寄存器写值（一个字节） */
/* 入口参数：reg   要写的寄存器地址          */
/*           value 给寄存器写的值            */
/* 出口参数：status 状态值                   */
/*********************************************/
uchar NRF24L01_Write_Reg(uchar reg,uchar value)
{
	uchar status;

	 digitalWrite(3,LOW);//NRF_CSN=0;                  //CSN=0;   
  	status = SPI_RW(reg);		//发送寄存器地址,并读取状态值
	SPI_RW(value);
	digitalWrite(3,HIGH);;                  //CSN=1;

	return status;
}
/*************************************************/
/* 函数功能：读24L01的寄存器值 （一个字节）      */
/* 入口参数：reg  要读的寄存器地址               */
/* 出口参数：value 读出寄存器的值                */
/*************************************************/
uchar NRF24L01_Read_Reg(uchar reg)
{
 	uchar value;

	digitalWrite(3,LOW);             //CSN=0;   
  	SPI_RW(reg);			//发送寄存器值(位置),并读取状态值
	value = SPI_RW(NOP);
	digitalWrite(3,HIGH);             	//CSN=1;

	return value;
}
/*********************************************/
/* 函数功能：读24L01的寄存器值（多个字节）   */
/* 入口参数：reg   寄存器地址                */
/*           *pBuf 读出寄存器值的存放数组    */
/*           len   数组字节长度              */
/* 出口参数：status 状态值                   */
/*********************************************/
uchar NRF24L01_Read_Buf(uchar reg,uchar *pBuf,uchar len)
{
	uchar status,u8_ctr;
	digitalWrite(3,LOW);                 	//CSN=0       
  	status=SPI_RW(reg);				//发送寄存器地址,并读取状态值   	   
 	for(u8_ctr=0;u8_ctr<len;u8_ctr++)
	pBuf[u8_ctr]=SPI_RW(0XFF);		//读出数据
	digitalWrite(3,HIGH);                 		//CSN=1
  	return status;        			//返回读到的状态值
}
/**********************************************/
/* 函数功能：给24L01的寄存器写值（多个字节）  */
/* 入口参数：reg  要写的寄存器地址            */
/*           *pBuf 值的存放数组               */
/*           len   数组字节长度               */
/**********************************************/
uchar NRF24L01_Write_Buf(uchar reg, uchar *pBuf, uchar len)
{
	uchar status,u8_ctr;
	digitalWrite(3,LOW);
  	status = SPI_RW(reg);			//发送寄存器值(位置),并读取状态值
  	for(u8_ctr=0; u8_ctr<len; u8_ctr++)
	SPI_RW(*pBuf++); 				//写入数据
	digitalWrite(3,HIGH);
  	return status;          		//返回读到的状态值
}							  					   

/*********************************************/
/* 函数功能：24L01接收数据                   */
/* 入口参数：rxbuf 接收数据数组              */
/* 返回值： 0   成功收到数据                 */
/*          1   没有收到数据                 */
/*********************************************/
uchar NRF24L01_RxPacket(uchar *rxbuf)
{
	uchar state;
	 
	state=NRF24L01_Read_Reg(STATUS);  			//读取状态寄存器的值    	 
	NRF24L01_Write_Reg(WRITE_REG+STATUS,state); //清除TX_DS或MAX_RT中断标志
	if(state&RX_OK)								//接收到数据
	{
		digitalWrite(12,LOW);//CE=0
		NRF24L01_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
		NRF24L01_Write_Reg(FLUSH_RX,0xff);					//清除RX FIFO寄存器
		digitalWrite(12,HIGH);//CE=1
		delay_150us(); 
		return 0; 
	}	   
	return 1;//没收到任何数据
}
/**********************************************/
/* 函数功能：设置24L01为发送模式              */
/* 入口参数：txbuf  发送数据数组              */
/* 返回值； 0x10    达到最大重发次数，发送失败*/
/*          0x20    成功发送完成              */
/*          0xff    发送失败                  */
/**********************************************/
uchar NRF24L01_TxPacket(uchar *txbuf)
{
	uchar state;
   
	digitalWrite(12,LOW);												//CE拉低，使能24L01配置
  	NRF24L01_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);	//写数据到TX BUF  32个字节
 	digitalWrite(12,HIGH);												//CE置高，使能发送	   
	while(digitalRead(7)==1);										//等待发送完成  irq=1
	state=NRF24L01_Read_Reg(STATUS);  						//读取状态寄存器的值	   
	NRF24L01_Write_Reg(WRITE_REG+STATUS,state); 			//清除TX_DS或MAX_RT中断标志
	if(state&MAX_TX)										//达到最大重发次数
	{
		NRF24L01_Write_Reg(FLUSH_TX,0xff);					//清除TX FIFO寄存器 
		return MAX_TX; 
	}
	if(state&TX_OK)											//发送完成
	{
		return TX_OK;
	}
	return 0xff;											//发送失败
}

/********************************************/
/* 函数功能：检测24L01是否存在              */
/* 返回值；  0  存在                        */
/*           1  不存在                      */
/********************************************/ 	  
uchar NRF24L01_Check(void)
{
	uchar check_in_buf[5]={0x11,0x22,0x33,0x44,0x55};
	uchar check_out_buf[5]={0x00};

	digitalWrite(6,LOW);
	digitalWrite(3,LOW);    
	digitalWrite(12,LOW);

	NRF24L01_Write_Buf(WRITE_REG+TX_ADDR, check_in_buf, 5);

	NRF24L01_Read_Buf(READ_REG+TX_ADDR, check_out_buf, 5);

	if((check_out_buf[0] == 0x11)&&\
	   (check_out_buf[1] == 0x22)&&\
	   (check_out_buf[2] == 0x33)&&\
	   (check_out_buf[3] == 0x44)&&\
	   (check_out_buf[4] == 0x55))return 0;
	else return 1;
}			


void NRF24L01_RT_Init(void)
{	
	digitalWrite(12,LOW);//NRF_CE=0;		  
  	NRF24L01_Write_Reg(WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度
	NRF24L01_Write_Reg(FLUSH_RX,0xff);									//清除RX FIFO寄存器    
  	NRF24L01_Write_Buf(WRITE_REG+TX_ADDR,(uchar*)TX_ADDRESS,TX_ADR_WIDTH);//写TX节点地址 
  	NRF24L01_Write_Buf(WRITE_REG+RX_ADDR_P0,(uchar*)RX_ADDRESS,RX_ADR_WIDTH); //设置TX节点地址,主要为了使能ACK	  
  	NRF24L01_Write_Reg(WRITE_REG+EN_AA,0x01);     //使能通道0的自动应答    
  	NRF24L01_Write_Reg(WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收地址  
  	NRF24L01_Write_Reg(WRITE_REG+SETUP_RETR,0x1a);//设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次
  	NRF24L01_Write_Reg(WRITE_REG+RF_CH,0);        //设置RF通道为2.400GHz  频率=2.4+0GHz
  	NRF24L01_Write_Reg(WRITE_REG+RF_SETUP,0x0F);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
  	NRF24L01_Write_Reg(WRITE_REG+CONFIG,0x0f);    //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开启所有中断
	digitalWrite(12,HIGH);//NRF_CE=1;									  //CE置高，使能发送
}

void SEND_BUF(uchar *buf)
{
	digitalWrite(12,LOW);//NRF_CE=0;
	NRF24L01_Write_Reg(WRITE_REG+CONFIG,0x0e);
	digitalWrite(12,HIGH);//NRF_CE=1;
	delay_us(15);
	NRF24L01_TxPacket(buf);
	digitalWrite(12,LOW);//NRF_CE=0;
	NRF24L01_Write_Reg(WRITE_REG+CONFIG, 0x0f);
	digitalWrite(12,HIGH);//NRF_CE=1;	
}
void loop()
{
	while(NRF24L01_Check()); // 等待检测到NRF24L01，程序才会向下执行
	NRF24L01_RT_Init();			
   if( isr_flag == 1 ) {  
     handleGesture();  
     if(digitalRead(APDS9960_INT) == 0){  
     apds.init();  
     apds.enableGestureSensor(true);  
   }  
   isr_flag = 0;  
   }*/
   handleGesture();
    if( isr_flag == 1 )
            {
              detachInterrupt(0);
              handleGesture();
              isr_flag = 0;
             // attachInterrupt(0, interruptRoutine, FALLING);
              attachInterrupt(0, interruptRoutine, CHANGE);
            } 
                if(1)
                {
                        rece_buf[1]='#';      
                        rece_buf[2]=b;
			rece_buf[3]=c;
			rece_buf[4]=d;
                        rece_buf[5]='G';
			rece_buf[6]=e;
                        rece_buf[7]=f;
                        rece_buf[8]=g;
                        rece_buf[9]='G';
                        rece_buf[10]=flag;
                        rece_buf[11]='*';
			rece_buf[0]=11;	   					//一共要发送11个字节，rece_buf[0]必须是11！！！！！！
			SEND_BUF(rece_buf);
                        flag='0';
                }
               // digitalWrite(2, LOW);
	//}
}

void interruptRoutine()
{
  isr_flag = 1;
}

void handleGesture()
{
    if ( apds.isGestureAvailable() ) 
    {
    switch ( apds.readGesture() ) 
    {
      case DIR_UP:
      flag='H';// jin ru ppt
        //Serial.println("UP");
        break;
      case DIR_DOWN:
      flag='I';// tui chu ppt
        //Serial.println("DOWN");
        break;
      case DIR_LEFT:
      flag='J';
        //Serial.println("LEFT");
        break;
      case DIR_RIGHT:
      flag='K';
        //Serial.println("RIGHT");
        break;
        
      /*case DIR_NEAR:
        Serial.println("NEAR");
        break;
      case DIR_FAR:
        Serial.println("FAR");
        break;*/
      //default:
      //flag='0';
        //Serial.println("NONE");
    }
  }
}