SparkFun Forums 

Where electronics enthusiasts find answers.

All things pertaining to wireless and RF links
By zdakun
#161766
I am sending message between two boards (TX and RX). After a message is sent, I put the board in power saving mode, and it is reset after every 1 seconds by watchdog. Later on, I will configure so it send the message every 5 seconds.
The problem is this: without putting in power saving mode, they transmit message very well, and I can see a reset every 1 seconds through LED. If it goes into power saving mode, I can still see it resets (as the LED signals), but no more transmission happens.
By commenting out line 194 as it is now ( or equivalently the 8th to last line), the code works; uncomment it, the transmission does not work anymore, though the chip clearly reset every 1 seconds.
I appreciate any help.

(PS: ignore some random characters, they are comments written in Chinese that can't be displayed here)

Code: Select all
// Ñ¡Ôñ0-30µÄÊý×Ö£¬¼ä¸ôΪ5MHz
#define CHANNEL 8
// µ±µÚÒ»¸ö°ü¹üûÓÐÊÕµ½Ê±£¬ÔÙ·¢Ë͵ĴÎÊý
#define REPEAT 1
// ·¢Ëͼä¸ô:ÃëÊý
#define INTERVAL 1

int channel = CHANNEL * 5;
int interval = INTERVAL * 128;


#include <Nordic\reg24le1.h>
#include <stdint.h>
#include "API.h"

#define	PIN32


#ifdef 	PIN32
sbit S3	 = P1^4;                               	// 1/0=δ°´/°´ÏÂ
sbit S2  = P1^3;                               	// 1/0=δ°´/°´ÏÂ
sbit S1  = P1^2;                               	// 1/0=δ°´/°´ÏÂ

sbit LED3 = P0^1;                               // 1/0=Ãð/ÁÁ
sbit LED2 = P0^2;                               // 1/0=Ãð/ÁÁ
sbit LED1 = P0^0;                               // 1/0=Ãð/ÁÁ

#endif

#define INTERRUPT_RFIRQ	9
#define INTERRUPT_TICK 	13  

#define TX_ADR_WIDTH    5   					// RFÊÕ·¢µØÖ·¹²5 bytes 
#define TX_PLOAD_WIDTH  20  					// Êý¾Ý°ü³¤¶ÈΪ20 bytes

uint8_t const TX_ADDRESS[TX_ADR_WIDTH]  = {0x34,0x56,0x78,0x90,0x12}; // ¶¨ÒåRFÊÕ·¢µØÖ·

uint8_t data id_buf[TX_PLOAD_WIDTH]={0xff, 0x01, 0x02, 0x03, 0x04, 0x05};

uint8_t bdata sta;
sbit	RX_DR	=sta^6;
sbit	TX_DS	=sta^5;
sbit	MAX_RT	=sta^4;
uint8_t warn;

/**************************************************
¹¦ÄÜ£ºÑÓʱ
**************************************************/
void delay(uint16_t x)
{
    uint16_t i,j;
    i=0;
    for(i=0;i<x;i++)
    {
       j=108;
           ;
       while(j--);
    }
}
/**************************************************
¹¦ÄÜ£ºÓ²¼þSPI¶Áд
**************************************************/
uint8_t SPI_RW(uint8_t value)
{
  SPIRDAT = value;
  											       
  while(!(SPIRSTAT & 0x02));  					// µÈ´ýSPI´«ÊäÍê³É

  return SPIRDAT;             					// ·µ»Ø¶Á³öÖµ
}
/**************************************************
¹¦ÄÜ£ºÐ´RF¼Ä´æÆ÷£¬¶ÁRF״ֵ̬
**************************************************/
uint8_t SPI_RW_Reg(uint8_t reg, uint8_t value)
{
	uint8_t status;

  	RFCSN = 0;                   	
  	status = SPI_RW(reg);      					// Ñ¡ÔñRF¼Ä´æÆ÷
  	SPI_RW(value);             					// дÈëÊý¾Ý
  	RFCSN = 1;                   	

  	return(status);            					// ·µ»ØRF״ֵ̬
}
/**************************************************
¹¦ÄÜ£º¶ÁRF¼Ä´æÆ÷
**************************************************/
uint8_t SPI_Read(uint8_t reg)
{
	uint8_t reg_val;

  	RFCSN = 0;                			
  	SPI_RW(reg);            					// Ñ¡ÔñRF¼Ä´æÆ÷
  	reg_val = SPI_RW(0);    					// ¶Á³öÊý¾Ý
  	RFCSN = 1;                			

  	return(reg_val);        					// ·µ»ØRF״ֵ̬
}
/**************************************************
¹¦ÄÜ£º°Ñ»º³åÇøµÄ¶à×Ö½ÚÊý¾Ýдµ½RF¼Ä´æÆ÷
**************************************************/
uint8_t SPI_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t bytes)
{
	uint8_t status,byte_ctr;

  	RFCSN = 0;                   		
  	status = SPI_RW(reg);    					// Ñ¡ÔñRF¼Ä´æÆ÷
  	for(byte_ctr=0; byte_ctr<bytes; byte_ctr++) // Á¬½ÓдÈëÊý¾Ý
    	SPI_RW(*pBuf++);
  	RFCSN = 1;                 			
  	return(status);          					// ·µ»ØRF״ֵ̬
}
/**************************************************
¹¦ÄÜ£ºÉèÖÃΪµôµçģʽ
**************************************************/
void PD_Mode(void)
{
	RFCE=0;
  	SPI_RW_Reg(WRITE_REG + CONFIG, 0x0c);   	// PWR_UP=0
}
/**************************************************
¹¦ÄÜ£ºÉèÖÃΪ·¢Éäģʽ
**************************************************/
void TX_Mode(void)
{
  	SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);     			// Éϵç, CRCΪ2 bytes,½ÓÊÕģʽ,ÔÊÐíRX_DR²úÉúÖжÏ
  	SPI_Write_Buf(WR_TX_PLOAD, id_buf, TX_PLOAD_WIDTH); // дÊý¾Ýµ½FIFO
	RFCE=1;												// Æô¶¯·¢Éä
	delay(10);											// ·¢ÉäÂö³å
	RFCE=0;												
}

void rf_init(void)
{
  	RFCE = 0;                                   		// RF off
  	RFCKEN = 1;                                 		// RF clock enable
  	RF = 1;                                     		// RF interrupt enable

	delay(1000);

  	SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    	// setting TX address length
  	SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); 	// setting RX address length

  	SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      			// automatically respond
  	SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  			// PIPE0 receive package
  	SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x11); 			// retransmit once
  	SPI_RW_Reg(WRITE_REG + RF_CH, channel);        			// RF frequency at 2440MHz
  	SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x20);   			// -16dBm, 250kbps,
  	SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); 	// PIPE0  received package length
}

void RF_IRQ(void) interrupt INTERRUPT_RFIRQ
{
	sta=SPI_Read(STATUS);								//read status
	SPI_RW_Reg(WRITE_REG+STATUS,0x70);					// clear interrupt
}


void main(void)
{
	/* watchdog enabled */
	CLKLFCTRL=0x01;
	WDSV=(interval%256);
	delay(10);
	WDSV=(interval/256);
	
	/* check for voltage through power-fail comparator*/
	/* eanble POF comparator at 2.7V threshold*/
	POFCON|=0xE0;
	/*check voltage: 0x10: below 2.7V; 0x00: above 2.7V*/
	
	warn = POFCON & 0x10;
	
	/* if voltage above 2.7V, start program */
	if(warn==0){
		/* ALL interrupts enabled */
		EA=1;
		EX1=0; // POFIRQ disabled
		/*LED control */
		P0DIR = 0xf0;						
		P1DIR = 0xff;
		LED2=1; //p0.2
		/* RF setting */
		rf_init();									// RF initialization               
		EA=1;                       // enable ALL interrupts
		
		while(1)
		{
			TX_Mode();								// send data
			while (!(TX_DS|MAX_RT));				// wait transmission end
			sta = 0;
			PD_Mode();								// turn off RF
			LED2=0; //p0.2
			//PWRDWN = 0x04;   // go into sleep
			delay(10);
		}
	}else{
		/* if voltage below 2.7V, go sleep */
		PWRDWN=0x04;
	}
}
By zdakun
#161844
I found the problem. Currently, I only sent once and it goes into sleep (the while(1) loop will only execute once). If I change it to make the TX send twice before going to sleep, then it would work.