nrf905_temperature._c

ADC采集温度数据通过nrf905发送出去

{
	PWR_UP_H;
	TX_EN_L;
	TRX_CE_H;
	us(650);
}

/////////////////////////////////////////////////////////////
BYTE spi_handle(BYTE cmd)
{
 	BYTE	len,i;
 	switch(cmd)		 {
	case R_CONFIG:
		len = 10;
		for ( i=0; i<10; i++ ) {
			if ( Register[i] != spi_rxbuf[i] )	return 1;
		}
		break;
	case R_RX_PAYLOAD:
		len = Register[3] & 0x3f;
		rxpt = 0;
		handlept = 0;
		FlashFlag = FLASHLIMIT;
		for ( i=0; i<len; i++ )	 {
			uart_TxChar(spi_rxbuf[i]);
		}

		rxpt = len;
		handle();
		break;
	case R_TX_ADDRESS:
		len = (Register[2] >> 4) & 0x07;
		for ( i=0; i<len; i++ ) {
			if ( tx_addr[i] != spi_rxbuf[i] )	return 1;
		}

		break;
	case R_TX_PAYLOAD:
		len = Register[4] & 0x3F;
		for ( i=0; i<len; i++ ) {
			if ( tx_buf[i] != spi_rxbuf[i] )	return 1;
		}

		break;
	}

	nrF905_RX_Mode();
	return 0;
}

/////////////////////////////////////////////////////////////
BYTE SPI_R_CONFIG()
{
 	BYTE	i;

	spi_rxpt = 0;
	spi_handlept = 0;
	nrF905_Standby_Mode();
	CSN_L;
 	SPI_Char(0,R_CONFIG);
	for ( i=0; i<10; i++ ) 	SPI_Char(1,0xff);

	CSN_H;
	return spi_handle(R_CONFIG);
}

/////////////////////////////////////////////////////////////
void SPI_W_CONFIG()
{
 	BYTE	i;

	nrF905_Standby_Mode();
	ms(10);
	while(1)	{
		CSN_L;
	 	SPI_Char(0,W_CONFIG);
		for ( i=0; i<10; i++ )	{
		 	SPI_Char(0,Register[i]);
		}

		CSN_H;

		if ( !SPI_R_CONFIG() )	break;
	}

	nrF905_RX_Mode();
}

/////////////////////////////////////////////////////////////
BYTE SPI_R_TX_PAYLOAD()
{
 	BYTE	i,len;

	spi_rxpt = 0;
	spi_handlept = 0;
	nrF905_Standby_Mode();
	CSN_L;
 	SPI_Char(0,R_TX_PAYLOAD);
	len = Register[4] & 0x3F;
	for ( i=0; i<len; i++ ) 	SPI_Char(1,0xff);

	CSN_H;
	return spi_handle(R_TX_PAYLOAD);
}

/////////////////////////////////////////////////////////////
void SPI_W_TX_PAYLOAD()
{
 	BYTE	i,len;

	CSN_L;
	SPI_Char(0,W_TX_PAYLOAD);

//	len = Register[4] & 0x3F;

    Register[4] = tx_len;
	for ( i=0; i<tx_len; i++ )	{
		SPI_Char(0,tx_buf[i]);
		uart_TxChar(tx_buf[i]);
	}
	CSN_H;
}

/////////////////////////////////////////////////////////////
BYTE SPI_R_TX_ADDRESS()
{
 	BYTE	i,len;

	spi_rxpt = 0;
	spi_handlept = 0;
	nrF905_Standby_Mode();
	CSN_L;
 	SPI_Char(0,R_TX_ADDRESS);
	len = (Register[2] >> 4) & 0x07;
	for ( i=0; i<len; i++ ) 	SPI_Char(1,0xff);

	CSN_H;
	return spi_handle(R_TX_ADDRESS);
}

/////////////////////////////////////////////////////////////
void SPI_W_TX_ADDRESS()
{
 	BYTE	i,len;

	CSN_L;
 	SPI_Char(0,W_TX_ADDRESS);
	len = (Register[2] >> 4) & 0x07;
	for ( i=0; i<len; i++ )	{
		SPI_Char(0,tx_addr[i]);
	}
	CSN_H;
}

/////////////////////////////////////////////////////////////
BYTE SPI_R_RX_PAYLOAD()
{
 	BYTE	i,len;

	spi_rxpt = 0;
	spi_handlept = 0;
	TRX_CE_L;
//	nrF905_Standby_Mode();
	CSN_L;
 	SPI_Char(0,R_RX_PAYLOAD);
	len = Register[3] & 0x3f;
	while(DR)	{
		SPI_Char(1,0xff);
	}

	CSN_H;
	return spi_handle(R_RX_PAYLOAD);
}

/////////////////////////////////////////////////////////////
void MakeFrame(BYTE cmd)
{
	BYTE	i;
 	switch(cmd)		{
	case CMD_ASKDATA:
		ms(100);
		CallData();
		break;
	case CMD_RETDATA:
		ms(100);
		RetData();
		
		break;
	case CMD_DOWNPARA:
		DownPara(spi_rxbuf[6]);
		break;
	case CMD_RETPARA:
		RetPara(spi_rxbuf[6]);
		break;
	case CMD_SETID:
		 SetID();
		 break;
       case CMD_SETID_OK:
	   	 SetIDOK();
		 break;
	default:   break;
	}

	for ( i=0; i<tx_len; i++ )	uart_TxChar(tx_buf[i]);

	for ( i=tx_len; i<16; i++ )	tx_buf[i] = 0;
}

/////////////////////////////////////////////////////////////
void SendGram(BYTE cmd)
{
 	MakeFrame(cmd);
	nrF905_RX_Mode();
	while(CD)	{;}
	while(AM)	{;}

	nrF905_TX_Mode();
	SPI_W_TX_ADDRESS();
	SPI_W_TX_PAYLOAD();
	TRX_CE_H;
	us(20);
	TRX_CE_L;
	while (!DR);

	nrF905_RX_Mode();
}

/////////////////////////////////////////////////////////////
void handle(void)
{
	BYTE	len,i;
	BYTE	lpc;
	if ( spi_rxbuf[0] != 0xeb )		return;
	if ( spi_rxbuf[1] != 0x90 )		return;

	if ( (spi_rxbuf[2] != CMD_SETID) && ((spi_rxbuf[2] != CMD_READID) )	{
		if (( spi_rxbuf[3] != ID_L ) || (spi_rxbuf[4] != ID_H))	return;
	}

	switch(spi_rxbuf[2])	{
	case CMD_ASKDATA:   
		                         len = 7; 
					     break;
	case CMD_SETID:       
		                         len = 6;
					     break;
	case CMD_RETDATA:
		                         len = 8+2*(num-startnum);
		                         break;
	case CMD_DOWNPARA:
		                         len = 14;
	                            	break;
	case CMD_READID:
		                         len = 4;
				            break;
	default:                     return;
	}

	if ( GetLPC(spi_rxbuf,len) )		return;


	switch(spi_rxbuf[2])	{
	case CMD_ASKDATA:
		num = spi_rxbuf[5];

		if(num>6)  num = 6;

		if(num != EEPROM_read(num_ADDR))  EEPROM_write(num_ADDR, num);

		startnum = 0;

		ms(2);
		
		SendGram(CMD_RETDATA);
		us(20);
		
		if( num >3) {
			us(20);
		   startnum = 4;
		   SendGram(CMD_RETDATA);
	        }
		
	
		break;
	case CMD_SETID:
		ID_L  = spi_rxbuf[3];
		ID_H = spi_rxbuf[4];
		EEPROM_write(ID_L_ADDR,ID_L);
		EEPROM_write(ID_H_ADDR,ID_H);
		SendGram(CMD_SETID_OK);
		break;

	case CMD_READID:
		 SendGram(CMD_SETID_OK);
		 break;
	case CMD_DOWNPARA:	
               num = spi_rxbuf[5];
		 EEPROM_write(num_ADDR, num);
		
		for(i=0;i<3;i++)	{
			limit[spi_rxbuf[6]][i] = (spi_rxbuf[8+2*i] << 8) + spi_rxbuf[7+2*i];
			EEPROM_write((LIMIT_START_ARRD+spi_rxbuf[6]*6+i*2),spi_rxbuf[7+2*i]);
		       EEPROM_write((LIMIT_START_ARRD+spi_rxbuf[6]*6+i*2+1), spi_rxbuf[8+2*i] << 8);
		}
		
		SendGram(CMD_RETPARA);
		
		break;
	default: break;
	}
}

/////////////////////////////////////////////////////////////
void ReceiveGram()
{
 	if ( !DR )	return;

//	SPI_R_CONFIG();
	SPI_R_RX_PAYLOAD();
}

/////////////////////////////////////////////////////////////
void timer0_init(void)
{
	TIMSK |= 0x01;
	NOP();
	TCCR0 = 0x05;
}

#pragma interrupt_handler timer0_ovf_isr:iv_TIMER0_OVF
void timer0_ovf_isr(void)
{
      adc_init();
}


void timer1_init(void)
{
	WORD	timer;

	timer=fosc/1024;
	TCNTData=0xffff-timer;
	TIMSK |= 0x04;
	NOP();
	TCCR1B = 0x00;
	TCNT1H = (TCNTData>>8)&0xff;
	TCNT1L = TCNTData&0xff;
	OCR1AH = 0x00;
	NOP();
	OCR1AL = 0x00;
	NOP();
	OCR1BH = 0x00;
	NOP();
	OCR1BL = 0x00;
	NOP();
	TCCR1A = 0x00;
	NOP();
	TCCR1B = 0x05;
}

/////////////////////////////////////////////////////////////////////////////////
#pragma interrupt_handler timer1_ovf_isr:iv_TIMER1_OVF
void timer1_ovf_isr(void)
{
      WORD msecond;
      
	  
	TCNT1H = (TCNTData>>8)&0xff;;
	NOP();
	TCNT1L = TCNTData&0xff;

	Count++;
	if ( Count < 120 )	WDR();

	if ( FlashFlag )	{
		if ( FlashFlag % 2 )	LED_L;
		else					LED_H;

		FlashFlag--;
	}
	else	LED_H;

	SecondCount++;
	if ( SecondCount % 2 )		SendDataFlag  = 1;

	if ( SecondCount >= SENDTIMER )	{
		SecondCount = 0;
//		spi_txflag = 1;
	}
       if(++msecond >1000)   AlarmPro();
      
}
/////////////////////////////////////////////////////////////////////////////////
void put_str(char *str)
{
	int	i,len;
	len = strlen(str);
	for ( i=0; i<len; i++ )
		uart_TxChar(str[i]);
}

/////////////////////////////////////////////////////////////////////////////////
void put_str_CRLF(char *str)
{
	put_str(str);
	uart_TxChar(0x0d);
	uart_TxChar(0x0a);
}

/////////////////////////////////////////////////////////////////////////////////
void wdt_init(void)
{
	WDR();//喂狗
	WDTCR|=(BIT(WDCE)|BIT(WDE));
	WDTCR=BIT(WDP2)|BIT(WDP1)|BIT(WDP0)|BIT(WDE);
}
/////////////////////////////////////////////////////////////////////////////////
//uart完成中断
#pragma interrupt_handler uart_Rx_isr:iv_USART_RXC
void uart_Rx_isr(void)
{
	rxbuf[rxpt] = UDR;
	rxpt++;
	rxpt &= RXBUF_LEN1;
}

/////////////////////////////////////////////////////////////////////////////////
void Spi_InitRegister(void)
{
//	Register[0] = 0x6c;									// 433.2MHZ
//	Register[1] = 0x0c;									//不重发，正常模式，输出+10dBm,433M频段
	Register[0] = CH_NO_BYTE;							// 433.2MHZ
	Register[1] = PA_PWR_10dBm | HFREQ_PLL_433MHz;		//不重发，正常模式，输出+10dBm,433M频段
	Register[2] = 0x44;									//TX、RX地址宽度为4
	Register[3] = 0x10;									//收为16个有效数据
	Register[4] = 0x10;									//发为16个有效数据
	Register[5] = ADDR_1;									//本机收地址
	Register[6] = ADDR_2;
	Register[7] = ADDR_3;
	Register[8] = ADDR_4;
	Register[9] = 0xD8;   //CRC校验16位，16M晶振

	tx_addr[0] = ADDR_1;
	tx_addr[1] = ADDR_2;
	tx_addr[2] = ADDR_3;
	tx_addr[3] = ADDR_4;

	TxFlag[0] = 0;
	TxFlag[1] = 0;
	TxFlag[2] = 0;
	TxFlag[3] = 0;
	TxFlag[4] = 0;
	TxFlag[5] = 0;
}

/////////////////////////////////////////////////////////////
void InitSPI(void)
{
	Spi_InitRegister();
	SPI_MasterInit();
	SPI_W_CONFIG();
}
/*////////////////////////////////////////////////////////////
void uart_handle(void)
{
	int		len,len1,i;
	BYTE	cmd,lpc=0xff;

	len = (rxpt - handlept) & RXBUF_LEN1;
	if ( len < 5 )	return;
	while(len > 0)	{
		if ( handlept == rxpt )		return;

		if ( rxbuf[handlept] != 0xeb )	{
			handlept = (handlept + 1) & RXBUF_LEN1;
			len--;
			continue;
		}

		if ( len < 2 )	return;
		if ( rxbuf[(handlept+1) & RXBUF_LEN1] != 0x90 )	{
			handlept = (handlept + 2) & RXBUF_LEN1;
			len -= 2;
			continue;
		}

		if ( len < 5 )	return;
		cmd = rxbuf[(handlept+2) & RXBUF_LEN1];
		if ( cmd != CMD_SETID )	{
			if ( ID != rxbuf[(handlept+3) & RXBUF_LEN1] )	{
				handlept = (handlept + 4) & RXBUF_LEN1;
				len -= 4;
				continue;
			}
		}

		switch(cmd)	{
		case CMD_ASKDATA:
			len1 = 5;
			break;
		case CMD_SETID:
			len1 = 5;
			break;
		case CMD_DOWNPARA:
			len1 = 11;
			break;
		case CMD_SETMODE:
			len1 = 6;
			break;
		}

		if ( len < len1 )	return;

		for ( i=0; i<len1; i++ )
			lpc ^= rxbuf[(handlept+i) & RXBUF_LEN1];

		if ( lpc )	{
			handlept = (handlept + len1) & RXBUF_LEN1;
			len -= len1;
			continue;
		}

		switch(cmd)	{
		case CMD_ASKDATA:
			SendData();
			put_bytes(tx_buf,tx_len);
			break;
		case CMD_SETMODE:
			Mode = rxbuf[(handlept+4) & RXBUF_LEN1];
			SetMode();
			put_bytes(tx_buf,tx_len);
			break;
		case CMD_SETID:
			ID = rxbuf[(handlept+3) & RXBUF_LEN1];
			EEPROM_write(ID_ADDR,ID);
			SetID();
uart_TxChar('3');
			put_bytes(tx_buf,tx_len);
			break;
		case CMD_DOWNPARA:
			for(i=0;i<3;i++){
				Limit_V[i]=rxbuf[(handlept+4+2*i) & RXBUF_LEN1] + (rxbuf[(handlept+5+2*i) & RXBUF_LEN1] << 8);
			}
			SendSetPara();
			put_bytes(tx_buf,tx_len);
			break;
		}

		handlept = (handlept + len1) & RXBUF_LEN1;
		len -= len1;
	}
}
////////////////////////////////////////////////////////////
*/
void main(void)
{
	int		count=0,i,j;

//	wdt_init();

   	DDRC  &= 0xC0;//设C口为高阻输入
	PORTC &= 0xC0;
	
	ID_L = EEPROM_read(ID_L_ADDR);
	ID_H = EEPROM_read(ID_H_ADDR);

      for(i=0;i<8;i++) {
           for(j=0;j<3;j++) 
		  limit[i][j]=(EEPROM_read(LIMIT_START_ARRD+i*6+j*2))|((EEPROM_read(LIMIT_START_ARRD+i*6+j*2))<<8);
	  }

	spi_rxpt = 0;
	spi_handlept = spi_rxpt;

	uart_init();
	
	timer0_init();
	
	timer1_init();

	InitSPI();
	
	SEI();//开中断
	
	Mode = 0;
	while(1)	{
		Count = 0;
		ReceiveGram();
//		uart_handle();

		if ( Mode )	{
			if ( SendDataFlag )	{
				SendDataFlag = 0;
				RetData();
				put_bytes(tx_buf,tx_len);
				SendGram(CMD_RETDATA);
			}
		}
	 }
   
}