3,849
社区成员
发帖
与我相关
我的任务
分享nRF24L01基于arduino UNO板的收发程序（无bug）
楼主处女贴，贴出最近写的基于arduino UNO板的nRF24L01接收与发射程序，实现功能：发送方每隔1.5s发送16字节数据包给接收方。程序无BUG，但是也有一些问题：比如我程序中发射过程中CE一直是高，没有做到低功耗。贴出来供大家交流，共同进步
...全文
请发表友善的回复…
发表回复
zkk12345 2015-08-28
- 打赏
- 举报
您好，此贴非常有用。请问可以放出接受程序和注释学习一下吗？
helldealer2015 2015-07-06
- 打赏
- 举报
上面的连起来是发送程序，程序的详细中文注解在下面的接收程序里
helldealer2015 2015-07-06
- 打赏
- 举报
/*--------------------------------
Function: clearTXFIFO()
Description:
Clear TXFIFO geg.
*/
void clearTXFIFO(void){
digitalWrite(CSN,LOW);
SPI.transfer(FLUSH_TX);
delayMicroseconds(10);
digitalWrite(CSN,HIGH);
}
/*--------------------------------
Function send_data()
Description:
This function initializes one nRF24L01 chip to TX Mode,
AND send data.
*/
unsigned char send_data(unsigned char *buf)
{
unsigned int uiNum;
byte sta;
power_off();
digitalWrite(CE,LOW);
RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable Auto.Ack:Pipe0
RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable Pipe0
RW_Reg(WRITE_REG + SETUP_RETR, 0x1a); // 500us + 86us, 10 retrans...
RW_Reg(WRITE_REG + RF_CH, 0); // Select RF channel 40
RW_Reg(WRITE_REG + RF_SETUP, 0x07); // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, 0x05); // Writes TX_Address to nRF24L01
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, 0x05); // RX_Addr0 same as TX_Adr for Auto.Ack
RW_Reg(FLUSH_TX,0x00);
SPI_Write_Buf(WR_TX_PLOAD, buf, TX_PLOAD_WIDTH); // Writes data to TX payload
//Serial.println(SPI_Read(TX_ADDR),HEX);
RW_Reg(WRITE_REG + CONFIG, 0x0e); // Set PWR_UP bit, enable CRC(2 unsigned chars) & Prim:TX. MAX_RT & TX_DS enabled..
digitalWrite(IRQ,HIGH);
digitalWrite(CE,HIGH);
delayMicroseconds(200);
//digitalWrite(CE,LOW);
//Serial.println("sendhalf");
uiNum = 0;
while(digitalRead(IRQ) == 1) {
if (uiNum > 20000) {
uiNum = 0;
ifnnrf_CLEAR_ALL();
// Serial.print("IRQ == 1");
//delay(1000);
return 0;
}
else {
uiNum++;
delayMicroseconds(10);
}
}
/*
if(digitalRead(IRQ)==0)
{
Serial.print("IRQ == 0!!!");
}
sta = SPI_Read(STATUS);
Serial.print(sta,HEX);
sta = SPI_Read(FIFO_STATUS);
Serial.println(sta,HEX);
*/
if (SPI_Read(STATUS) & STA_MARK_TX) {
RW_Reg(WRITE_REG+STATUS,0xFF); // 清除所有中断标志
clearTXFIFO();
// Serial.print("STA1");
return 1;
}
else {
RW_Reg(WRITE_REG+STATUS,0xFF); // 清除所有中断标志
clearTXFIFO();
//Serial.print("STA0");
}
return 0;
}
/*-------------------------
Function: receive_data()
Description:
Receive data from the sender.
*/
unsigned char receive_data(unsigned char *buf){
unsigned char RXflag = 0;
if(digitalRead(IRQ) == 0){
if (SPI_Read(STATUS) & STA_MARK_RX) {
SPI_Read_Buf(RD_RX_PLOAD,buf,TX_PLOAD_WIDTH);
RXflag = 1;
RW_Reg(WRITE_REG+STATUS,0xff); // 清除所有中断标志
}
else {
ifnnrf_CLEAR_ALL();
RXflag = 0;
}
}
digitalWrite(IRQ,HIGH);
return RXflag;
}
/*-------------------------
*/
void SPI_CLR_Reg(byte R_T){
digitalWrite(CSN,LOW);
if(R_T == 1)
SPI.transfer(FLUSH_TX);
else
SPI.transfer(FLUSH_RX);
digitalWrite(CSN,HIGH);
}
/*--------------------------
*/
void ifnnrf_CLEAR_ALL(){
SPI_CLR_Reg(0);
SPI_CLR_Reg(1);
RW_Reg(WRITE_REG+STATUS,0xff);
pinMode (IRQ, INPUT);
digitalWrite(IRQ,HIGH);
}
helldealer2015 2015-07-06
- 打赏
- 举报
#include <SPI.h>
#define TX_ADR_WIDTH 5 // 5 unsigned chars TX(RX) address width
#define TX_PLOAD_WIDTH 16 // 32 unsigned chars TX payload
byte READ_REG = 0x00; // Define read command to register
byte WRITE_REG = 0x20; // Define write command to register
byte RD_RX_PLOAD = 0x61; // Define RX payload register address
byte WR_TX_PLOAD = 0xA0; // Define TX payload register address
byte FLUSH_TX = 0xE1; // Define flush TX register command
byte FLUSH_RX = 0xE2; // Define flush RX register command
#define REUSE_TX_PL 0xE3 // Define reuse TX payload register command
#define NOP 0xFF // Define No Operation, might be used to read status register
//***************************************************//
// SPI(nRF24L01) registers(addresses)
#define CONFIG 0x00 // 'Config' register address
#define EN_AA 0x01 // 'Enable Auto Acknowledgment' register address
#define EN_RXADDR 0x02 // 'Enabled RX addresses' register address
#define SETUP_AW 0x03 // 'Setup address width' register address
#define SETUP_RETR 0x04 // 'Setup Auto. Retrans' register address
#define RF_CH 0x05 // 'RF channel' register address
#define RF_SETUP 0x06 // 'RF setup' register address
#define STATUS 0x07 // 'Status' register address
#define OBSERVE_TX 0x08 // 'Observe TX' register address
#define CD 0x09 // 'Carrier Detect' register address
#define RX_ADDR_P0 0x0A // 'RX address pipe0' register address
#define RX_ADDR_P1 0x0B // 'RX address pipe1' register address
#define RX_ADDR_P2 0x0C // 'RX address pipe2' register address
#define RX_ADDR_P3 0x0D // 'RX address pipe3' register address
#define RX_ADDR_P4 0x0E // 'RX address pipe4' register address
#define RX_ADDR_P5 0x0F // 'RX address pipe5' register address
#define TX_ADDR 0x10 // 'TX address' register address
#define RX_PW_P0 0x11 // 'RX payload width, pipe0' register address
#define RX_PW_P1 0x12 // 'RX payload width, pipe1' register address
#define RX_PW_P2 0x13 // 'RX payload width, pipe2' register address
#define RX_PW_P3 0x14 // 'RX payload width, pipe3' register address
#define RX_PW_P4 0x15 // 'RX payload width, pipe4' register address
#define RX_PW_P5 0x16 // 'RX payload width, pipe5' register address
#define FIFO_STATUS 0x17 // 'FIFO Status Register' register address
#define STA_MARK_RX 0X40
#define STA_MARK_TX 0X20
#define STA_MARK_MX 0X10
byte TX_ADDRESS[TX_ADR_WIDTH] = {
0x34,0x43,0x10,0x10,0x01}; // Define a static TX address
byte const RX_ADDRESS[TX_ADR_WIDTH] = {
0x34,0x43,0x10,0x10,0x01};
//***************************************************************//
// FUNCTION's PROTOTYPES //
//****************************************************************
void RF_init(); // Init HW or SW SPI
byte SPI_Read(byte reg); // Read one unsigned char from nRF24L01
unsigned char RW_Reg(byte reg, byte value); // Write one unsigned char to register 'reg'
unsigned char SPI_Write_Buf(byte reg, byte *pBuf, byte bytes); // Writes multiply unsigned chars to one register
unsigned char SPI_Read_Buf(byte reg, byte *pBuf, byte bytes); // Read multiply unsigned chars from one register
void RX_Mode(void);
void clearTXFIFO(void);
unsigned char send_data(unsigned char *buf);
unsigned char receive_data(unsigned char *buf);
void ifnnrf_CLEAR_ALL();
void SPI_CLR_Reg(byte R_T);
int IRQ = 8;
int CE = 9;
int CSN = 10;
unsigned char txData[32]={
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
unsigned char rxData[32]={
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f};
void setup() {
pinMode (CSN, OUTPUT);
pinMode (CE, OUTPUT);
pinMode (IRQ, INPUT);
digitalWrite(IRQ,HIGH);
SPI.begin();
Serial.begin(9600);
RF_init();
delay(10);
Serial.print("System initialization compeleted!");
void RX_Mode();
}
void loop() {
if(send_data(txData)==1)
{
Serial.println("send success");
delay(1500);
}else
{
Serial.println("send fail");
delay(1500);
}
}
//---------------------------------------------------------------------
//NRF24l01 function
/*-----------------------
Function: init();
Description:
initialize the NRF24L01 chip.
*/
void RF_init(){
digitalWrite(CE,LOW); //chip enable
digitalWrite(CSN,HIGH); //Spi disable
}
/*------------------------
Function: RW_Reg();
Description:
Writes value 'value' to register 'reg'
*/
unsigned char RW_Reg(byte reg,byte value){
unsigned char sta = 0;
digitalWrite(CSN,LOW);
sta = SPI.transfer(reg);
SPI.transfer(value);
digitalWrite(CSN,HIGH);
return(sta);
}
/*--------------------------
*/
byte SPI_Read(byte reg)
{
byte reg_val;
digitalWrite(CSN,LOW); // CSN low, initialize SPI communication...
SPI.transfer(reg); // Select register to read from..
reg_val = SPI.transfer(0); // ..then read registervalue
digitalWrite(CSN,HIGH); // CSN high, terminate SPI communication
return(reg_val); // return register value
}
/*---------------------------
Function:SPI_Read_Buf();
Description:
Reads 'unsigned chars' of unsigned chars from regester 'reg'
Typically used to read RX payload,RX/TX address
*/
unsigned char SPI_Read_Buf(byte reg,byte *pBuf,byte bytes){
unsigned char sta,byte_ctr;
digitalWrite(CSN,LOW);
sta = SPI.transfer(reg);
for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)
pBuf[byte_ctr] = SPI.transfer(0);
digitalWrite(CSN,HIGH);
return(sta);
}
/*------------------------------
Function:SPI_Write_Buf()
Description:
Writes contents of buffer '*pBuf' to nRF24L01
Typically used to write TX payload,Rx/Tx address
*/
unsigned char SPI_Write_Buf(byte reg,byte *pBuf,byte bytes){
unsigned char sta,byte_ctr;
digitalWrite(CSN,LOW);
sta = SPI.transfer(reg);
for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)
SPI.transfer(*pBuf++);
digitalWrite(CSN,HIGH);
return(sta);
}
/*-------------------------------
Function power_off()
Description:
This function initializes one nRF24L01 device to
Power off Mode.
*/
void power_off(){
digitalWrite(CE,LOW);
RW_Reg(WRITE_REG+CONFIG,0x0D);
digitalWrite(CE,HIGH);
delay(160);
}
/*-------------------------------
Function RX_Mode()
Description:
This function initializes one nRF24L01 device to RX Mode
Set RX address,writes RX payload width,select RF channel,
datarate & LNA HCURR.
After init,CE is TOGGLED to high, which means that this
device is now ready to receave a datapacket.
*/
void RX_Mode(){
power_off();
digitalWrite(CE,LOW);
SPI_Write_Buf(WRITE_REG+TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // Writes TX_Address to nRF24L01
SPI_Write_Buf(WRITE_REG+RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);
RW_Reg(WRITE_REG+EN_AA,0x00);
RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable Pipe0
RW_Reg(WRITE_REG + RF_CH, 0); // Select RF channel 40
RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width
RW_Reg(WRITE_REG + RF_SETUP, 0x07); // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR
RW_Reg(WRITE_REG + CONFIG, 0x0f); // Set PWR_UP bit, enable CRC(2 unsigned chars) & Prim:RX. RX_DR enabled..
RW_Reg(WRITE_REG+STATUS,0xff); // 清除所有中断标志
digitalWrite(CE,HIGH); // Set CE pin high to enable RX device
delay(1);
}
