arx.c

nRF24z1的c51参考代码

#include <REG2051.H>
#include <intrins.h>
#include "ARX.h" 


code unsigned char channel_num[38]=
{
	0x06, 0x1c, 0x34, 0x4c, 0x18,
	0x30, 0x48, 0x14, 0x2c, 0x44,
	0x10, 0x28, 0x40, 0x0c, 0x24,
	0x3c, 0x08, 0x20, 0x38, 0x04,
	0x1e, 0x36, 0x4e, 0x1a, 0x32,
	0x4a, 0x16, 0x2e, 0x46, 0x12,
	0x2a, 0x42, 0x0e, 0x26, 0x3e,
	0x0a, 0x22, 0x3a
};

BYTE gbLedTimer = 0;

BYTE gbKeyPressed = 0;
BYTE gbKeyLastId;
BYTE gbKeyRept;
BYTE gbKeyId;
BYTE gbVolume;
void KeyDetect(void);


#define	i2c_delay()	\
	{		\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	_nop_();	\
	}



void timer0(void) interrupt 1
{
	TR0 = 0;
	gbLedTimer++;
	if(gbLedTimer >25){
		gbLedTimer = 0;
		if(LED_CON == 0)LED_CON = 1;
		else LED_CON = 0;
	}	
	KeyDetect();
	
	TH0 = 0xB1;
	TL0 = 0xE0;
	TR0 = 1;
}   

void KeyDetect(void)
{
	BYTE	bKey;
	
	bKey = KEY_INVALID;
	
	if(VOLUP_KEY == 0) bKey = KEY_VOL_UP;
	else if(VOLDN_KEY == 0) bKey = KEY_VOL_DOWN;
	else if(PWR_KEY == 1) bKey = KEY_UP;
	
	if( gbKeyPressed )
	{
		if( (gbKeyLastId & KEY_ID) != bKey )
		{
			if( gbKeyRept > KEY_REPT_COUNT ){
				
				gbKeyLastId |= KEY_BREAK;
				gbKeyPressed  = 0;
				gbKeyRept     = 0;
			}
			else {
				gbKeyPressed  = 0;
				gbKeyRept     = 0;
			}
		}
		else
		{
			if( gbKeyRept < KEY_REPT_LONG_COUNT )
			{
				gbKeyRept++;
				gbKeyLastId = bKey;

			}
			else	gbKeyLastId = (bKey|KEY_LONG);
		}
	}
	else
	{
		if( (bKey>KEY_INVALID)&& !(gbKeyLastId&KEY_BREAK) )
		{
			gbKeyPressed = 1;
			gbKeyLastId = bKey;
			gbKeyRept    = 0;
		}
	}
	if( gbKeyId == KEY_GET_DONE )
	{
		gbKeyId = gbKeyLastId;
		if( !gbKeyPressed )	gbKeyLastId = KEY_INVALID;
	}
}

BYTE KeyGet( void )		
{				
	BYTE bKeyValue;
	ET0  = 0;		
	bKeyValue = gbKeyId;	
	gbKeyId = KEY_GET_DONE;
	ET0 = 1;
	return 	bKeyValue;	
}				


void I2C_Start(BYTE device)
{
	if(device == DEVICE_RF)
	{
		I2C_SDA = 1; 	
		I2C_SCL = 1;
		i2c_delay();
		I2C_SDA = 0;
		i2c_delay();
		I2C_SCL = 0; 	
		i2c_delay();
	}
	else 
	{
		DAC_SDA = 1; 	
		DAC_SCL = 1;
		i2c_delay();
		DAC_SDA = 0;
		i2c_delay();
		DAC_SCL = 0; 	
		i2c_delay();
	}
}

void I2C_Stop(BYTE device)
{
	if(device == DEVICE_RF)
	{
		I2C_SDA = 0;
		i2c_delay();
		I2C_SCL = 1;
		i2c_delay();
		I2C_SDA = 1;
		i2c_delay();
		I2C_SCL = 0;
		i2c_delay();
	}
	else {
		DAC_SDA = 0;
		i2c_delay();
		DAC_SCL = 1;
		i2c_delay();
		DAC_SDA = 1;
		i2c_delay();
		DAC_SCL = 0;
		i2c_delay();
	}
}

void I2C_clock(BYTE device)
{
	if(device == DEVICE_RF)
	{
		I2C_SCL = 1;
		i2c_delay();
		I2C_SCL = 0;
		i2c_delay();
	}
	else {
		DAC_SCL = 1;
		i2c_delay();
		DAC_SCL = 0;
		i2c_delay();
	}
}

BYTE I2C_read_ack(BYTE device)
{
	BYTE sample;
	
	if(device == DEVICE_RF)
	{
		I2C_SCL = 1;
		i2c_delay();
		if(I2C_SDA == 0)sample = 0;
		else sample = 1;
		
		I2C_SCL = 0;
		i2c_delay();
	
		if (sample==0) return (0);
		else return (1);
	}
	else {
		DAC_SCL = 1;
		i2c_delay();
		if(DAC_SDA == 0)sample = 0;
		else sample = 1;
		
		DAC_SCL = 0;
		i2c_delay();
	
		if (sample==0) return (0);
		else return (1);
	}
}

void I2C_ack (BYTE device)
{ 
	if(device == DEVICE_RF)
	{
		I2C_SDA = 0; 
		I2C_clock(device);
		I2C_SDA = 1; 
	}
	else {
		DAC_SDA = 0;
		I2C_clock(device);
		DAC_SDA = 1; 
	}
}

BYTE I2C_send(BYTE device, BYTE i_data)
{
	BYTE i;
	if(device == DEVICE_RF)
	{
		for (i=0;i<8;i++)
		{
			if (i_data&0x80) 
			{
		     	   	I2C_SDA = 1;
		     	}
		     	else 
		     	{	
				I2C_SDA = 0;
		     	}
		 	i_data=i_data<<1;
		 	I2C_clock(device);
		}
	 	//charles	
		I2C_SDA = 1;
	}
	else {
		for (i=0;i<8;i++)
		{
			if (i_data&0x80) 
			{
		     	   	DAC_SDA = 1;
		     	}
		     	else 
		     	{	
				DAC_SDA = 0;
		     	}
		 	i_data=i_data<<1;
		 	I2C_clock(device);
		}
	 	//charles	
		DAC_SDA = 1;
	}
	return (!I2C_read_ack(device));
}

BYTE I2C_wr_single_data(BYTE device, BYTE device_id, BYTE addr, BYTE i_data)
{
	I2C_Start(device);
	if(I2C_send(device, device_id))
	{
		if(I2C_send(device, addr))
		{
			if(I2C_send(device, i_data))
			{
				I2C_Stop(device);
				
				return(1);
			}
			else 
			{
				I2C_Stop(device);
				//LED_CON = 1;
				return(0);
			}
		}
		else {
			I2C_Stop(device);
			//LED_CON = 1;
			return(0);
		}
	}
	else {
		
		I2C_Stop(device);
		//LED_CON = 1;
		return(0);
	}
}

BYTE I2C_read_bit(BYTE device)
{
	BYTE sample;
	if(device == DEVICE_RF)
	{	
		I2C_SCL = 1;	
		i2c_delay();
		if(I2C_SDA == 0) sample = 0;
		else sample = 1;
		I2C_SCL = 0;
		i2c_delay();
	
		if (sample==0) return (0);
		else return (1);
	}
	else {
		DAC_SCL = 1;	
		i2c_delay();
		if(DAC_SDA == 0) sample = 0;
		else sample = 1;
		DAC_SCL = 0;
		i2c_delay();
	
		if (sample==0) return (0);
		else return (1);
	}	
}

BYTE I2C_rd_data(BYTE device)
{
	BYTE i,i_data=0;
	
	for (i=0;i<8;i++)
	{
		i_data*=2;
	    	if (I2C_read_bit(device)) i_data++;
	}
	
	return(i_data);
}
void mcu_wait_ms(unsigned int count)
{
	
	while(count--);
}

BYTE I2C_rd_single_data(BYTE device, BYTE device_id, BYTE addr, BYTE i_data)
{
	I2C_Start(device);
	if(I2C_send(device, device_id))
	{
		if(I2C_send(device, addr))
		{
			I2C_Start(device);
			if(I2C_send(device, device_id|0x01))
			{
				i_data = I2C_rd_data(device);
				I2C_ack(device);
				I2C_Stop(device);
				return(1);
			}
			else {
				I2C_Stop(device);
				return(0);
			}
				
		}
		else {
			I2C_Stop(device);
			return(0);
		}
	}
	else {
		I2C_Stop(device);
		return(0);
	}
}

void dac_init(void) {
	
	
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x1E, 0x00);    // Resetting DAC before continuing with init, page 20
	
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x0E, 0x12);    // Slave mode, I2S, 16 bits, page 26
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x12, 0x01);    // Activate digital interface, page 31
	
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x0A, 0x00);    // 3 Disable mute, disable de-emphasis, page 15
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x10, 0x20);    // 256x at 44.1ksps, page 26?
	
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x08, 0x10);    // 1 Select DAC, page 17. It has to be put in here and not in dac_init()
        
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x0c, 0x67);    // 2 Power down CLKOUT and oscillator, enable output, DAC, and VMID page 33
	
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x05, gbVolume|0x80);
	DAC_PD = 1;
}


void dac_volume_up()
{
	if(gbVolume < 0x7f) gbVolume++;
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x05, gbVolume|0x80);
}

void dac_volume_down()
{
	if(gbVolume > 0x30) gbVolume--;
	I2C_wr_single_data(DEVICE_DAC, DAC_WR_ADDR, 0x05, gbVolume|0x80);
}

void ARX_init(void)
{
	BYTE bI;
	//---------------Link Table------------------------------
	for(bI=0; bI<38; bI++)
	{
		I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, CH0+bI, channel_num[bI]);
	}
	
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, BCHD, 0x0A);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, NBCH, 0x12);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, NACH, 0x26);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, NLCH, 0x26);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, LNKMOD, 0x00);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, LNKWTH, 0xFF);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, LNKETH, 0xFF);
	
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, ADDR_0, 0x98);	// Data for ADDR_0
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, ADDR_1, 0x38);	// Data for ADDR_1
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, ADDR_2, 0xA2);	// Data for ADDR_2
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, ADDR_3, 0x34);	// Data for ADDR_3
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, ADDR_4, 0x85);	// Data for ADDR_4  
	
	
	//-------------Interrupts table--------------------------
	//I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, INTSTA, 0x00);	// 
	//I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, INTCF, 0x02);	// Enable wakeup from power down interrupt
	//-------------ATX set table-----------------------------
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, TXSTA, 0x49);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, TXPWR, 0x03);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, TXFMT, 64);//  i2s
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, I2SCNF_IN, 0x80);//master
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, TXLAT, 0x04);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, TXMOD, 0x82);
	//------------ARX set table------------------------------
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, RXSTA, 0x08);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, RXPWR, 0x03);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, I2SCNF_OUT, 0);
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, RXMOD, 0x20);
	//------------data command-------------------------------
	I2C_wr_single_data(DEVICE_RF, ARX_WR_ADDR, RXDCMD, 0x82);
}

#if 1
void mcu_init(void)
{
	                                     
	IE = 0x00;

/*	IP (Interrupt Priority Set)
	    (MSB)							(LSB)
	        D7  	D6  	D5  	D4  	D3  	D2  	D1  	D0
	     --------------------------------------------------------------
	    |       |       |       |       |       |       |       |       |
	    |   -   |  	-   |   -   |  PS   |  PT1  |  PX1  |  PT0  |  PX0  |
	    |   0   |   0   |   0   |   1   |   0   |   0   |   1   |   1   |
	    |       |       |       |       |       |       |       |       |
	     ---------------------------------------------------------------	*/
   	IP = 0x13;                                            

/*	TMOD (Timer & Counter Mode Control)
	    (MSB)							(LSB)
	        D7  	D6  	D5  	D4  	D3  	D2  	D1  	D0
	     --------------------------------------------------------------
	    |  TM1  |  TM1  |  TM1  |  TM1  |  TM0  |  TM0  |  TM0  |  TM0  |
	    | GATE  |  C/T  |  M1   |  M0   | GATE  |  C/T  |  M1   |  M0   |
	    |   0   |   0   |   1   |   0   |   0   |   0   |   0   |   1   |
	    |  int  |int clk|reload |       |       |int clk|       |       |
	     ---------------------------------------------------------------	*/
   	TMOD = 0x21;                                           

/*	TCON (Timer & Counter Control)
	    (MSB)							(LSB)
	        D7  	D6  	D5  	D4  	D3  	D2  	D1  	D0
	     --------------------------------------------------------------
	    |       |       |       |       |       |       |  VD   |  VD   |
	    |  TF1  |  TR1  |  TF0  |  TR0  |  IE1  |  IT1  |  IE0  |  IT0  |
	    |   0   |   0   |   0   |   0   |   0   |   1   |   0   |   1   |
	    |over f |tm1 oN |over f |tm0 off|1edge f|1 type |0edge f|0 type |
	     ---------------------------------------------------------------	*/
   	TCON = 0x00;                                           

                                  

/*	SCON(Serial Port Control )
	    (MSB)							(LSB)
	        D7  	D6  	D5  	D4  	D3  	D2  	D1  	D0
	     --------------------------------------------------------------
	    |       |       |       |RXenabl|9th bit|9th bit|       |       |
	    |  SM0  |  SM1  |  SM2  |  REN  |  TB8  |  RB8  |  TI   |  RI   |
	    |   0   |   1   |   0   |   1   |   0   |   0   |   0   |   0   |
	    |       |       |Multi x|       |       |       |       |       |
	     ---------------------------------------------------------------	*/
   	SCON = 0x00;                                           

/*	PCON(Power Control Set )
	    (MSB)							(LSB)
	        D7  	D6  	D5  	D4  	D3  	D2  	D1  	D0
	     --------------------------------------------------------------
	    |       |       |       |       |       |       |       |       |
	    | SMOD  |  	-   |   -   |   -   |  GF1  |  GF2  |  PD   |  IDL  |
	    |   1   |   0   |   0   |   0   |   0   |   0   |   0   |   0   |
	    |  baud |       |       |       |  flag |  flag |powerdn|Idlebit|
	     ---------------------------------------------------------------	*/
   	PCON = 0x10;                                           

/*	TH0H,L (Timer 0 Byte) */
   	TH0 = 0xB1;
	TL0 = 0xE0;                                          


	P1 = 0xFF;

	P3 = 0x7f;
}
#endif
main(void)
{
	BYTE bTemp = 0;
	BYTE bCurKey = 0;
	gbKeyRept    = 0;
	gbKeyId     = KEY_INVALID;
	gbKeyLastId = KEY_INVALID;
	gbKeyPressed = 0;
	
	gbVolume = 0x79;
	gbLedTimer = 0;
	
	mcu_init();
	PWR_EN = 1;
	LED_CON = 0;
	EA = 0;
	TR0 = 0;
	ARX_init();
	LED_CON = 1;
	dac_init();
	mcu_wait_ms(4000);
	
	I2C_rd_single_data(DEVICE_RF, ARX_WR_ADDR, I2SCNF_OUT, bTemp);	
	//if(bTemp==0x40)
	//{
	//	LED_CON = 0;
	//	while(1);
	//}
	EA = 1;
	ET0 = 1;
	TR0 = 1;
	while(1)
	{
		
		bCurKey = KeyGet();
			
		switch(bCurKey)
		{
		case KEY_VOL_UP_BREAK:
		case KEY_VOL_UP_LONG:	
			dac_volume_up();
			break;
		case KEY_VOL_DOWN_BREAK:
		case KEY_VOL_DOWN_LONG:
			dac_volume_down();
			break;
		case KEY_UP_LONG:
			EA = 0;
			while(1){
				LED_CON = 0;
				PWR_EN = 0;
			}
			
		}
		mcu_wait_ms(10000);
	}
}