maintutorial3local.c

nRF24L01开发指导

/*****************************************************************************
*
* File: maintutorial3local.c
* 
* Copyright S. Brennen Ball, 2007
* 
* The author provides no guarantees, warantees, or promises, implied or
*	otherwise.  By using this software you agree to indemnify the author
* 	of any damages incurred by using it.
* 
*****************************************************************************/

#include "lpc214x.h"
#include "spi1.h"
#include "delays.h"
#include "nrf24l01.h"
#include "uart0.h"

//for the following 9 definitions, see Jim Lynch's ARM tutorial
#define PLOCK 0x400

void Initialize();
void InitializePLL();
void InitializeIO();
void Feed();

void IRQ_Routine()   __attribute__ ((interrupt("IRQ")));
void FIQ_Routine()   __attribute__ ((interrupt("FIQ")));
void SWI_Routine()   __attribute__ ((interrupt("SWI")));
void UNDEF_Routine() __attribute__ ((interrupt("UNDEF")));
//end Jim Lynch's definitions

void ToggleLED(); //toggle the current state of the on-board LED
bool Ping(); //send and receive packet

#define NUM_PINGS	5 //number of times to ping each channel
#define PING_DELAY	2 //seconds to wait between pings

//main routine
int	main() 
{		
	unsigned char i, j; //inner and outer loop variables
	unsigned char pipe_count[6]; //stores successful pings
	unsigned char tx_addr[5]; //temporary variable to hold TX address for current pipe
	unsigned int total; //temporary variable to hold the total successful pings
	
	Initialize(); //initialize PLL, IO, UART, SPI, set up nRF24L01 as TX

	//main program loop
	while(1)
	{
		//clear successful pings
		for(i = 0; i < 6; i++)
			pipe_count[i] = 0;
		
		//announce the process is beginning
		uart0_printf("Testing link:\n");
		
		//ping all 6 ports
		for(i = 0; i < 6; i++)
		{	
			//set the TX address for the pipe with the same number as the iteration
			switch(i)
			{
				case 0: //setup TX address as default RX address for pipe 0 (E7:E7:E7:E7:E7)
					tx_addr[0] = tx_addr[1] = tx_addr[2] = tx_addr[3] = tx_addr[4] = nrf24l01_RX_ADDR_P0_B0_DEFAULT_VAL;
					nrf24l01_set_tx_addr(tx_addr, 5);
					break;
				case 1: //setup TX address as default RX address for pipe 1 (C2:C2:C2:C2:C2)
					tx_addr[0] = tx_addr[1] = tx_addr[2] = tx_addr[3] = tx_addr[4] = nrf24l01_RX_ADDR_P1_B0_DEFAULT_VAL;
					nrf24l01_set_tx_addr(tx_addr, 5);
					break;
				case 2: //setup TX address as default RX address for pipe 2 (C2:C2:C2:C2:C3)
					tx_addr[0] = nrf24l01_RX_ADDR_P2_DEFAULT_VAL;
					nrf24l01_set_tx_addr(tx_addr, 1);
					break;
				case 3: //setup TX address as default RX address for pipe 3 (C2:C2:C2:C2:C4)
					tx_addr[0] = nrf24l01_RX_ADDR_P3_DEFAULT_VAL;
					nrf24l01_set_tx_addr(tx_addr, 1);
					break;
				case 4: //setup TX address as default RX address for pipe 4 (C2:C2:C2:C2:C5)
					tx_addr[0] = nrf24l01_RX_ADDR_P4_DEFAULT_VAL;
					nrf24l01_set_tx_addr(tx_addr, 1);
					break;
				case 5: //setup TX address as default RX address for pipe 5 (C2:C2:C2:C2:C6)
					tx_addr[0] = nrf24l01_RX_ADDR_P5_DEFAULT_VAL;
					nrf24l01_set_tx_addr(tx_addr, 1);
					break;
			}

			//ping the pipe NUM_PINGS times
			//if the ping is successful (returns true), increment the pipe_count variable for this pipe
			for(j = 0; j < NUM_PINGS; j++)
				if(Ping())
					pipe_count[i]++;
			
			//output stats for this pipe		
			uart0_printf("  pinging pipe %u (%x:%x:%x:%x:%x): %u/%u (%u%%)\n", i, tx_addr[4], tx_addr[3], tx_addr[2], tx_addr[1], tx_addr[0], pipe_count[i], NUM_PINGS, (pipe_count[i] * 100)/NUM_PINGS);
		}
		
		//find the total number of successful pings, and then output overall statistics
		total = pipe_count[0] + pipe_count[1] + pipe_count[2] + pipe_count[3] + pipe_count[4] + pipe_count[5];
		uart0_printf("  TOTAL: %u/%u (%u%%)\n\n", total, NUM_PINGS * 6, (total * 100)/(NUM_PINGS * 6));
									
		ToggleLED(); //toggle the on-board LED as visual indication that the loop has completed
		
		DelayS(PING_DELAY); //wait specified number of seconds until the next set of pings (default is 2 seconds)
	}
}

//ping the current pipe with one byte of data
bool Ping()
{
	unsigned char data = 0xFF; //register to hold byte sent and received
	unsigned int count; //counter for for loop
	
	nrf24l01_write_tx_payload(&data, 1, true); //transmit received char over RF

	//wait until the packet has been sent or the maximum number of retries has been reached
	while(!(nrf24l01_irq_pin_active() && nrf24l01_irq_tx_ds_active()));

	nrf24l01_irq_clear_all(); //clear all interrupts in the 24L01
	nrf24l01_set_as_rx(true); //change the device to an RX to get the character back from the other 24L01

	//wait a while to see if we get the data back (change the loop maximum and the lower if
	//  argument (should be loop maximum - 1) to lengthen or shorten this time frame
	for(count = 0; count < 25000; count++)
	{
		//check to see if the data has been received.  if so, get the data and exit the loop.
		//  if the loop is at its last count, assume the packet has been lost and set the data
		//  to go to the UART to "?".  If neither of these is true, keep looping.
		if((nrf24l01_irq_pin_active() && nrf24l01_irq_rx_dr_active()))
		{
			nrf24l01_read_rx_payload(&data, 1); //get the payload into data
			break;
		}
		
		//if loop is on its last iteration, assume packet has been lost.
		if(count == 24999)
			data = 0;
	}
	
	nrf24l01_irq_clear_all(); //clear interrupts again

	DelayUS(130); //wait for receiver to come from standby to RX
	nrf24l01_set_as_tx(); //resume normal operation as a TX

	//if the packet came back correctly, return true...otherwise, return false
	if(data == 0xFF)
		return true;
	else
		return false;
}

//initialize routine
void Initialize()
{
	InitializePLL(); //initialize PLL (Jim Lynch function)
	InitializeIO(); //set up IO (directions and functions)
	uart0_open(); //open UART0
	spi1_open(); //open SPI1
	nrf24l01_initialize_debug(false, 1, false);
}

//initialize IO pins
void InitializeIO()
{
	SCS = 0x03; // select the "fast" version of the I/O ports
	FIO1DIR3 = 0x01; //set LED bit as output
	FIO1PIN3 = 0x00; //turn LED on (pin is 0)
	
	FIO0DIR = 0x007A0001; //set CE, CSN, MISO1, SCK1, and TX as outputs (and another control bit on my particular board)
	FIO0PIN = 0x00500000; //set CSN bit (and another control bit on my particular board)
	PINSEL0 = 0x00000005; //set up UART0 pins as UART0 instead of GPIO
	PINSEL1 = 0x000000A8; //set up SPI1 pins as SPI1 instead of GPIO
}

//toggles on-board LED
void ToggleLED()
{
	if((FIO1PIN3 & 0x01) == 0x00)
		FIO1PIN3 = 0x01;
	else
		FIO1PIN3 = 0x00;
}

//initialize PLL to 5x (Jim Lynch function)
void InitializePLL()  
{
	// Setting Multiplier and Divider values
  	PLLCFG=0x24;
  	Feed();
  
	// Enabling the PLL */	
	PLLCON=0x1;
	Feed();
  
	// Wait for the PLL to lock to set frequency
	while(!(PLLSTAT & PLOCK));
  
	// Connect the PLL as the clock source
	PLLCON=0x3;
	Feed();
  
	// Enabling MAM and setting number of clocks used for Flash memory fetch (4 cclks in this case)
	MAMCR=0x2;
	MAMTIM=0x4;

	VPBDIV=0x01;
}

//operate PLL Feed (Jim Lynch function)
void Feed()
{
	PLLFEED=0xAA;
	PLLFEED=0x55;
}

//the following 4 stubs are functions by Jim Lynch
void IRQ_Routine() 
{
}

void FIQ_Routine()  
{
}

void SWI_Routine()  
{
}

void UNDEF_Routine() 
{
}