nrf905_jinju.c

监测高压电电流

	LED_L;

	CLI();
	DDRB = 0x08 |0x20| 0x04|0x01;
	MISO_H;
	CSN_H;
	SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
	SPSR = 0x00;
	temp = SPSR;
	temp = SPCR;
	SEI();
}

/////////////////////////////////////////////////////////////
void SPI_Char(BYTE rxflag,char c)
{
	SPDR = c;
	while(!(SPSR & (1<<SPIF)));

 	if ( rxflag )	{
		spi_rxbuf[spi_rxpt] = SPDR;
		spi_rxpt = (spi_rxpt+1)&SPI_BUF_LEN1;
	}
}

/////////////////////////////////////////////////////////////
void nrF905_PowerOff_Mode()
{
	PWR_UP_L;
}

/////////////////////////////////////////////////////////////
void nrF905_Standby_Mode()
{
	PWR_UP_H;
	TRX_CE_L;
}

/////////////////////////////////////////////////////////////
void nrF905_TX_Mode()
{
	PWR_UP_H;
	TX_EN_H;
	TRX_CE_L;
}

/////////////////////////////////////////////////////////////
void nrF905_RX_Mode()
{
	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);


    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;
	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(5);
		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;
		
		SendGram(CMD_RETDATA);
		
		if( num >4) {
			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_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)
{
     static BYTE i;

	 i++;
	 
	 if(i>20){
      adc_init();
	  i = 0;
	 }
}


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)
{
    
	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;
	}
	    
     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 main(void)
{
	int		count=0,i,j;



   	DDRC  &= 0xC0;//设C口为高阻输入
	PORTC &= 0xC0;
	
	ID_L = EEPROM_read(ID_L_ADDR);
	ID_H = EEPROM_read(ID_H_ADDR);
      num = EEPROM_read(num_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();

	 }
   
}