精华内容
下载资源
问答
  • 两个Arduino nano + nRF24L01实现双向通信
  • ArduinoNrf24l01通信

    2017-12-23 12:30:16
    ArduinoNrf24l01通信,代码包含主从两部分,直接使用Arduino库,代码简单精炼
  • Arduino NRF24L01无线收发模块完整例子,包含源代码,库文件,上位机
  • Arduino NRF24L01 +接收器库。 允许Arduino由各种玩具四轴飞行器发射机控制(例如Cheerson CX10,Syma X5)。 实现几种发射器协议,以便您可以使用便宜的四轴发射器来控制Arduino。 实现了各种Cheerson,JJRC和...
  • 用于nRF24L01 2.4GHz无线收发器的STM32duino驱动程序 这是maniacbug RF24库的修改版本,可在找到。 它已被修改为可与Arduino平台上的stm32f103一起使用。 可以在这里找到该项目。 设计目标:该库旨在... 最大限度...
  • Arduino_Library_NRF24L01P NRF24L01P(NRF24L01+)的Arduino
  • 用于ESP32的nRF24L01p库(esp-idf) 简单用法示例 /* Sender */ CNRFLib nrf (GPIO_NUM_16, GPIO_NUM_17); nrf.AttachToSpiBus(HSPI_HOST); uint8_t buff[ 32 ] = { 0 }; nrf.Begin(nrf_tx_mode); nrf.Send(buff, 32...
  • Arduino 本意为开源 开放,有很多的库,但是参差不齐,这个24L01+换了很多的库 都nm不行,真是无语,在网上找了一段程序 改了下,终于可以简单通信了 记录下: CE: 模块控制线,CSN为低时,CE协同CONFIG寄存器共同...

    Arduino 本意为开源 开放,有很多的库,但是参差不齐,这个24L01+换了很多的库 都nm不行,真是无语,在网上找了一段程序 改了下,终于可以简单通信了

    记录下:

    CE: 模块控制线,CSN为低时,CE协同CONFIG寄存器共同决定NRF24L01状态
    CSN: SPI片选线
    SCK: SPI时钟线
    MOSI:SPI数据线(主机输出从机输入)
    MISO:SPI数据线(主机输入从机输出)
    IRQ: 中断信号线。中断时变为低电平,在以下三种情况变低:Tx FIFO发完并且收到ACK(使能ACK情况下)、Rx FIFO收到数据、达到最大重发次数

    这里中断可用可不用,Arduino UNO才放了2个中断口,这种业余的MCU查询也不误事

    这种无线通信模块通常都是绑定地址,固定信道,调频什么的,固定套路,这里找了一个模拟SPI的驱动,经简单验证可以收发

    附上代码:
    这里从串口收到数据,用NRF发送出去,另一端的2.4g接受后串口打出来,都是裸数据,无协议

    TX

    
    #include "NRF24L01.h"
    String comdata = "";//字符串函数
    #define TX_NAME  "32899"
    
    
    
    /* 声明nRF24L01 */
    nRF24L01 nrf24;
    
    /* 建立发送数据缓存,初始化为0 */
    char buf[12] = {0};
    
    void setup() {
    	Serial.begin(9600);
        /* 初始化 nrf24 */         
    	nrf24.init();
        /* 配置数据宽度 */
        nrf24.payload = 10;
        /* 配置地址 */
    	nrf24.setTADDR(TX_NAME);
        /* 写入配置 */
    	nrf24.config();
    
    }
    
    void loop() {
        recv_uart_cmd();
        if (comdata.length() > 0)//如果comdata有数据
        {
          //Serial.println(comdata);//打印comdata数据
          strcpy(buf, comdata.c_str());
          Serial.println(buf);//打印comdata数据
          comdata = "";
          nrf24.send(buf);
          
        }
    }
    
    void recv_uart_cmd(void)
    {
      if (Serial.available() > 0)//判读是否串口有数据
      {
        comdata = "";//缓存清零
        while (Serial.available() > 0)//循环串口是否有数据
        {
          comdata += char(Serial.read());//叠加数据到comdata
          delay(2);//延时等待响应
        }
        //if (comdata.length() > 0)//如果comdata有数据
        //{
        //  Serial.println(comdata);//打印comdata数据
        //}
      }
    }
    

    RX :

    #include "NRF24L01.h"
    
    
    #define RX_NAME  "32899"
    
    /* 声明nRF24L01 */
    nRF24L01 nrf24;
    
    /* 建立接收数据缓存,初始化为0 */
    char buf[15];
    int  recv_cmd = 0;
    
    void setup() {
      Serial.begin(9600);
      nrf24.init();
      nrf24.payload = 10;
      nrf24.setRADDR(RX_NAME);
      nrf24.config();
      /* 设定中断 */
      //attachInterrupt(0, readData, LOW) ;
    }
    
    void loop() {
    
      readData ();
    
    }
    
    void readData (void)
    {
      if (nrf24.dataReady())
      {
        //Serial.println("Receiving the data!");
        nrf24.getData(buf);
        Serial.print("Data -> ");
        //Serial.print(buf);
        recv_cmd = atoi(buf);
        Serial.print(recv_cmd);
        Serial.println(" ");
    
      }
    }
    

    最后最重要的是要有 驱动的库支持
    这个文件夹放到Arduino 安装文件夹下就可,关于引脚的定义在
    NRF24L01.中

    /* 中断状态 */
    #define RX_IRQ		11
    #define TX_IRQ		22
    #define MAX_RT_IRQ	33
    
    /* 默认端口号 */
    #define CE       8   // CE_BIT:   Digital Input     Chip Enable Activates RX or TX mode
    #define CSN      10   // CSN BIT:  Digital Input     SPI Chip Select
    #define SCK      13  // SCK BIT:  Digital Input     SPI Clock
    #define MOSI     11  // MOSI BIT: Digital Input     SPI Slave Data Input
    #define MISO     12  // MISO BIT: Digital Output    SPI Slave Data Output, with tri-state option
    

    在这里插入图片描述
    Examples里面就是TX RX的Arduino程序,可以直接使用

    最后附上库的下载链接:

    https://download.csdn.net/download/weixin_39369053/19619997

    click here
    over

    展开全文
  • arduino 驱动Nrf24l01模块收发代码
  • 该程序旨在使用 433mhz 接收器从 LaCrosse 无线气象站接收数据,并通过 2.4Ghz NRF24L01+ 收发器从包含 DS18B20 温度传感器的最多 3 个不同无线 Arduino 节点接收数据。 包含用于 Arduino 无线节点的 Fritzing 原理...
  • 2020-02-09 Arduino nRF24L01无线遥控

    千次阅读 2020-02-09 18:27:27
    无线遥控器(含Arduino一块,nRF24L01一块,LCD16x2显示器IIC一块,Joystick手柄XYZ一把,彩色按钮5个!电池一块9V锂电池,亚克力板2块,杜邦线若干等) 我在这个小项目碰到的问题: 1,是nRF24L01的库,CE和CSN(7...

    材料:
    智能小车一辆(含驱动电机,4个;驱动板一块;Arduino一块;电池1.5V,6节;nRF24L01一块;其他杜邦线等)
    无线遥控器(含Arduino一块,nRF24L01一块,LCD16x2显示器IIC一块,Joystick手柄XYZ一把,彩色按钮5个!电池一块9V锂电池,亚克力板2块,杜邦线若干等)

    我在这个小项目碰到的问题:
    1,是nRF24L01的库,CE和CSN(7和8针脚)一定要看库里的定义!
    2,显示器和nRF24L01通信的冲突,有延时!
    3,按钮的消抖问题
    4,亚克力板制作花了我很多时间手动切割!

    辛苦了2个礼拜,总算搞好!感谢CSDN,让我学习了很多!完成了儿时的梦想!

    在这里插入图片描述在这里插入图片描述

    展开全文
  • arduinonrf24L01收发通信

    万次阅读 2018-06-23 14:08:54
    最近弄了两个nrf24l01的模块,想试试之后往智能家居上用,正好之前有一个小车用来验证导航算法的...nrf24l01采用SPI总线通信,虽然占引脚数多,但是收发速度快,模块通信速率可达2Mbps,而功耗控制在待机22uA,如果...

    最近弄了两个nrf24l01的模块,想试试之后往智能家居上用,正好之前有一个小车用来验证导航算法的,还有一个小四轴的控制手柄,所以萌生了结合三者弄个遥控车玩一玩。小四轴基于STC15系列主控,51架构,而小车主控是arduino平台,那么nrf24l01的代码就需要分开写。nrf24l01采用SPI总线通信,虽然占引脚数多,但是收发速度快,模块通信速率可达2Mbps,而功耗控制在待机22uA,如果掉电模式可以仅900nA,如果其余传感器功耗控制合理,用干电池驱动整个模块工作数月了,这可是其他通信模块不具备的特性,高速低耗,2.4Ghz的抗干扰能力也不错,穿透性稍差,但是家庭环境使用还是够的。

    官方给了C语言的库,先拿两个51单片机试了下,OK,再从网上下载了arudino的库,试了下,???无法收发,换个库,还是不行,纳闷了,对照手册看源码,经过数次修改,始终不能成功,手册我都看的快背下来了。遂放弃,想到51版本的可以用,那就根据51版本的改过来用呗,首先是基本的预处理宏定义,这个可以照搬,对照手册没有问题:

    RF24_config.h:

    /*
     Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
    
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     version 2 as published by the Free Software Foundation.
     */
    
    #ifndef __RF24_CONFIG_H__
    #define __RF24_CONFIG_H__
    
    #if ARDUINO < 100
    #include <WProgram.h>
    #else
    #include <Arduino.h>
    #endif
    
    #include <stddef.h>
    
    // Stuff that is normally provided by Arduino
    #ifdef ARDUINO
    #include <SPI.h>
    #else
    #include <stdint.h>
    #include <stdio.h>
    #include <string.h>
    extern HardwareSPI SPI;
    #define _BV(x) (1<<(x))
    #endif
    
    #undef SERIAL_DEBUG
    #ifdef SERIAL_DEBUG
    #define IF_SERIAL_DEBUG(x) ({x;})
    #else
    #define IF_SERIAL_DEBUG(x)
    #endif
    
    // Avoid spurious warnings
    #if 1
    #if ! defined( NATIVE ) && defined( ARDUINO )
    #undef PROGMEM
    #define PROGMEM __attribute__(( section(".progmem.data") ))
    #undef PSTR
    #define PSTR(s) (__extension__({static const char __c[] PROGMEM = (s); &__c[0];}))
    #endif
    #endif
    
    // Progmem is Arduino-specific
    #ifdef ARDUINO
    #include <avr/pgmspace.h>
    #define PRIPSTR "%S"
    #else
    typedef char const char;
    typedef uint16_t prog_uint16_t;
    #define PSTR(x) (x)
    #define printf_P printf
    #define strlen_P strlen
    #define PROGMEM
    #define pgm_read_word(p) (*(p)) 
    #define PRIPSTR "%s"
    #endif
    
    #endif // __RF24_CONFIG_H__
    // vim:ai:cin:sts=2 sw=2 ft=cpp
    

    然后照搬一个模块寄存器宏定义、引脚宏定义,nRF24L01.h:

    /*
        Copyright (c) 2007 Stefan Engelke <mbox@stefanengelke.de>
    
        Permission is hereby granted, free of charge, to any person 
        obtaining a copy of this software and associated documentation 
        files (the "Software"), to deal in the Software without 
        restriction, including without limitation the rights to use, copy, 
        modify, merge, publish, distribute, sublicense, and/or sell copies 
        of the Software, and to permit persons to whom the Software is 
        furnished to do so, subject to the following conditions:
    
        The above copyright notice and this permission notice shall be 
        included in all copies or substantial portions of the Software.
    
        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
        HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
        WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
        DEALINGS IN THE SOFTWARE.
    */
    
    /* Memory Map */
    #define CONFIG      0x00
    #define EN_AA       0x01
    #define EN_RXADDR   0x02
    #define SETUP_AW    0x03
    #define SETUP_RETR  0x04
    #define RF_CH       0x05
    #define RF_SETUP    0x06
    #define STATUS      0x07
    #define OBSERVE_TX  0x08
    #define CD          0x09
    #define RX_ADDR_P0  0x0A
    #define RX_ADDR_P1  0x0B
    #define RX_ADDR_P2  0x0C
    #define RX_ADDR_P3  0x0D
    #define RX_ADDR_P4  0x0E
    #define RX_ADDR_P5  0x0F
    #define TX_ADDR     0x10
    #define RX_PW_P0    0x11
    #define RX_PW_P1    0x12
    #define RX_PW_P2    0x13
    #define RX_PW_P3    0x14
    #define RX_PW_P4    0x15
    #define RX_PW_P5    0x16
    #define FIFO_STATUS 0x17
    #define DYNPD	    0x1C
    #define FEATURE	    0x1D
    
    /* Bit Mnemonics */
    #define MASK_RX_DR  6
    #define MASK_TX_DS  5
    #define MASK_MAX_RT 4
    #define EN_CRC      3
    #define CRCO        2
    #define PWR_UP      1
    #define PRIM_RX     0
    #define ENAA_P5     5
    #define ENAA_P4     4
    #define ENAA_P3     3
    #define ENAA_P2     2
    #define ENAA_P1     1
    #define ENAA_P0     0
    #define ERX_P5      5
    #define ERX_P4      4
    #define ERX_P3      3
    #define ERX_P2      2
    #define ERX_P1      1
    #define ERX_P0      0
    #define AW          0
    #define ARD         4
    #define ARC         0
    #define PLL_LOCK    4
    #define RF_DR       3
    #define RF_PWR      6
    #define RX_DR       6
    #define TX_DS       5
    #define MAX_RT      4
    #define RX_P_NO     1
    #define TX_FULL     0
    #define PLOS_CNT    4
    #define ARC_CNT     0
    #define TX_REUSE    6
    #define FIFO_FULL   5
    #define TX_EMPTY    4
    #define RX_FULL     1
    #define RX_EMPTY    0
    #define DPL_P5	    5
    #define DPL_P4	    4
    #define DPL_P3	    3
    #define DPL_P2	    2
    #define DPL_P1	    1
    #define DPL_P0	    0
    #define EN_DPL	    2
    #define EN_ACK_PAY  1
    #define EN_DYN_ACK  0
    
    /* Instruction Mnemonics */
    #define READ_REG    0x00
    #define WRITE_REG    0x20
    #define REGISTER_MASK 0x1F
    #define ACTIVATE      0x50
    #define R_RX_PL_WID   0x60
    #define R_RX_PAYLOAD  0x61
    #define W_TX_PAYLOAD  0xA0
    #define W_ACK_PAYLOAD 0xA8
    #define FLUSH_TX      0xE1
    #define FLUSH_RX      0xE2
    #define REUSE_TX_PL   0xE3
    #define NOP           0xFF
    
    /* Non-P omissions */
    #define LNA_HCURR   0
    
    /* P model memory Map */
    #define RPD         0x09
    
    /* P model bit Mnemonics */
    #define RF_DR_LOW   5
    #define RF_DR_HIGH  3
    #define RF_PWR_LOW  1
    #define RF_PWR_HIGH 2
    
    #define TX_ADR_WIDTH    5     // 5 uints TX address width
    #define RX_ADR_WIDTH    5     // 5 uints RX address width
    #define TX_PLOAD_WIDTH  20    // 20 uints TX payload
    #define RX_PLOAD_WIDTH  20    // 20 uints TX payload
    

    然后是与模块通信的代码:类class RF24,头文件如下:

    #ifndef __RF24_H__
    #define __RF24_H__
    
    class RF24
    {
    private:
      uint8_t ce_pin; /**< "Chip Enable" pin, activates the RX or TX role */
      uint8_t csn_pin; /**< SPI Chip select */
      bool wide_band; /* 2Mbs data rate in use? */
      bool p_variant; /* False for RF24L01 and true for RF24L01P */
      uint8_t payload_size; /**< Fixed size of payloads */
      bool ack_payload_available; /**< Whether there is an ack payload waiting */
      bool dynamic_payloads_enabled; /**< Whether dynamic payloads are enabled. */ 
      uint8_t ack_payload_length; /**< Dynamic size of pending ack payload. */
      uint64_t pipe0_reading_address; /**< Last address set on pipe 0 for reading. */
      uint8_t TX_ADDRESS[TX_ADR_WIDTH];
      uint8_t RX_ADDRESS[RX_ADR_WIDTH];
    public:
      RF24(uint8_t _cepin, uint8_t _cspin);
      void csn(int mode);
      void ce(int level);
      uint8_t SPI_RW(uint8_t dat);
      uint8_t  SPI_READ(uint8_t reg);
      uint8_t  SPI_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars);
      uint8_t  SPI_Read_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars);
      uint8_t  SPI_RW_Reg(uint8_t reg, uint8_t value);
      void SetRX_Mode(void);
      void SetTX_Mode(void);
      bool nRF24L01_RxPacket( uint8_t * buf, uint8_t len );
      bool nRF24L01_TxPacket( uint8_t * tx_buf);
      void init_NRF24L01(void);
    };
    #endif // __RF24_H__
    

    实现根据c51版本的改:

    #include "nRF24L01.h"
    #include "RF24_config.h"
    #include "RF24.h"
    
    RF24::RF24(uint8_t _cepin, uint8_t _cspin):
      ce_pin(_cepin), csn_pin(_cspin), wide_band(true), p_variant(false), 
      payload_size(20), ack_payload_available(false), dynamic_payloads_enabled(false),
      pipe0_reading_address(0)
    {
      // Minimum ideal SPI bus speed is 2x data rate
      // If we assume 2Mbs data rate and 16Mhz clock, a
      // divider of 4 is the minimum we want.
      // CLK:BUS 8Mhz:2Mhz, 16Mhz:4Mhz, or 20Mhz:5Mhz
    #ifdef ARDUINO
      SPI.setBitOrder(MSBFIRST);
      SPI.setDataMode(SPI_MODE0);
      SPI.setClockDivider(SPI_CLOCK_DIV4);
    #endif
      pinMode(ce_pin,OUTPUT);
      pinMode(csn_pin,OUTPUT);
      SPI.begin();
      //TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; 
      RX_ADDRESS[0]= 0x34;
      RX_ADDRESS[1]= 0x43;
      RX_ADDRESS[2]= 0x10;
      RX_ADDRESS[3]= 0x10;
      RX_ADDRESS[4]= 0x01;
      TX_ADDRESS[0]= 0x34;
      TX_ADDRESS[1]= 0x43;
      TX_ADDRESS[2]= 0x10;
      TX_ADDRESS[3]= 0x10;
      TX_ADDRESS[4]= 0x01;
    }
    
    void RF24::init_NRF24L01(void)
    {
       ce(LOW);
      csn(HIGH);
      //sck(LOW); 
      SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    
      SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); 
      SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      
      SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  
      SPI_RW_Reg(WRITE_REG + RF_CH, 0x6e);        
      SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH);
      SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x27);       
    }
    
    void RF24::csn(int mode)
    {
      digitalWrite(csn_pin,mode);
    }
    
    void RF24::ce(int level)
    {
      digitalWrite(ce_pin,level);
    }
    
    uint8_t RF24::SPI_RW(uint8_t dat){
        return SPI.transfer(dat);
      }
    
    uint8_t  RF24::SPI_READ(uint8_t reg){
        uint8_t reg_val ;
        csn(LOW);
        delayMicroseconds(12);
        SPI.transfer(reg);
        delayMicroseconds(12);
        reg_val = SPI.transfer(0);
        delayMicroseconds(12);
        csn(HIGH);
        return reg_val;
      }
    
    uint8_t  RF24::SPI_RW_Reg(uint8_t reg, uint8_t value)
    {
      uint8_t sta;  
      csn(LOW);                   // CSN low, init SPI transaction
      sta = SPI.transfer(reg);      // select register
      SPI.transfer(value);             // ..and write value to it..
      csn(HIGH);                   // CSN high again
      
      return(sta);            // return nRF24L01 status
    }
    
    uint8_t  RF24::SPI_Read_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
    {
      uint8_t sta,uchar_ctr;
      
      csn(LOW);            //SPIʹÄÜ       
      sta = SPI.transfer(reg);   
      for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
        pBuf[uchar_ctr]= SPI.transfer(0x0);
      csn(HIGH);           //¹Ø±ÕSPI
      return(sta);    // 
    }
    
    uint8_t  RF24::SPI_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
    {
      uint8_t sta,uchar_ctr;
      
      csn(LOW);            //SPIʹÄÜ       
      sta = SPI.transfer(reg);   
      for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
      SPI.transfer(*pBuf++);
      csn(HIGH);           //¹Ø±ÕSPI
      return(sta);    // 
    }
    
    void RF24::SetRX_Mode(void)
    {
      ce(LOW);
      SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);      // IRQÊÕ·¢Íê³ÉÖжÏÏìÓ¦£¬16λCRC £¬Ö÷½ÓÊÕ
      ce(HIGH);
    }
    
    void RF24::SetTX_Mode(void)
    {
      ce(LOW);
      SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);      // IRQÊÕ·¢Íê³ÉÖжÏÏìÓ¦£¬16λCRC £¬Ö÷½ÓÊÕ
      ce(HIGH);
    }
    
    bool RF24::nRF24L01_RxPacket( uint8_t * rx_buf, uint8_t len )
    {
      bool revale = false;
      uint8_t sta=0x00;
      sta = SPI_READ(STATUS);
      ce(LOW);
      if(sta & _BV(RX_DR)){
        //write_register(STATUS,_BV(RX_DR) );
          SPI_Read_Buf(R_RX_PAYLOAD,rx_buf,20);
          revale =true;
        }
     SPI_RW_Reg(WRITE_REG+STATUS,sta);
     delayMicroseconds(30);
     SPI_RW_Reg(0xE2,0xff);
     ce(HIGH);
     
     return revale;
    }
    
    bool RF24::nRF24L01_TxPacket( uint8_t * tx_buf)
    {
      ce(LOW);
      SPI_RW_Reg(0xE1,0xff);  
      SPI_Write_Buf(W_TX_PAYLOAD, tx_buf,payload_size);            
      SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);    
      SPI_RW_Reg(WRITE_REG+STATUS,0xff);
     ce(HIGH);   
       delayMicroseconds(12);
    }
    
    void RF24::SPI_CLR_Reg(uint8_t R_T)
    {
        csn(LOW); 
      if(R_T==1)                  // CSN low, init SPI transaction
        SPI_RW(FLUSH_TX);             // ..and write value to it..
      else
      SPI_RW(FLUSH_RX);             // ..and write value to it..
        csn(HIGH);                  // CSN high again
    }
    
    void RF24::ifnnrf_CLERN_ALL()
    {
      SPI_CLR_Reg(0);
      SPI_CLR_Reg(1);
      SPI_RW_Reg(WRITE_REG+STATUS,0xff);
      //IRQ=1;
    }
    

    函数名都可以顾名思义,所以不必细说,实际用的时候可以直接引用,看调用方法:

    #include <SPI.h>
    #include "nRF24L01.h"
    #include "RF24.h"
    
    #define IRQ 8  //定义中断查询引脚
    
    //const uint64_t pipe =  0x3443101001LL;
    RF24 radio(9,10); //初始化类,定义引脚
    
    void setup(void)
    {
      Serial.begin(9600);
      radio.init_NRF24L01();  //初始化
      radio.SetTX_Mode();  //设置发送模式
    }
    
    void loop(void)
    {
      uint8_t command[20];
      bool done = false;
      char i=0;
      for(i=0;i<20;i++){ 
        command[i]='a'+i;
      }
      radio.nRF24L01_TxPacket(command);  //发送数据包
      while(digitalRead(IRQ)==HIGH);  //等待发送完成
    }

    接收与发射类似:

    #include <SPI.h>
    #include "nRF24L01.h"
    #include "RF24.h"
    
    //const uint64_t pipe =  0x3443101001LL;
    RF24 radio(9,10);
    
    void setup(void)
    {
      Serial.begin(9600);
      radio.init_NRF24L01();
    }
    
    void loop(void)
    {
      uint8_t command[20];
      bool done = false;
      char i=0;
      radio.SetRX_Mode();  //设置读模式
      delay(100);
      if(radio.nRF24L01_RxPacket(command,20)){  //接受数据包
         for(i=0;i<20;i++){ 
             Serial.print(command[i]);
             Serial.print('-');
         }
         Serial.println("*");
         radio.ifnnrf_CLERN_ALL();  //判断未读完
       }
    }

    经测试,OK。那既然两个平台都通了,可以试试在遥控器和小车上了。小四轴遥控器原本用的就是nrf24L01,将两个摇杆的位置信息映射到0~255的uchar类型,那么小车上只需要将nrf24L01模块地址设置为相同的接收地址,解析对应通道数据并转换成速度信息即可。由于理论上摇杆回中对应的值为128,但是实际摇杆回中值会有个浮动,导致当我没控制摇杆,即摇杆处于回中状态时小车会低速运动,因此,做个判断,将128附近值屏蔽,控制代码如下:

    #include <SPI.h>
    #include "nRF24L01.h"
    #include "RF24.h"
    
    RF24 radio(8,10);
    //引脚定义
    int motorLF = 14;
    int motorLB = 15;
    int motorRF = 16;
    int motorRB = 17;
    int pwmLSpeed = 3;
    int pwmRSpeed = 5;
    
    byte leftSpeed = 0;
    byte rightSpeed = 0;
    uint8_t command[20];
    
    void setup(void)
    {
        Serial.begin(9600);
        radio.init_NRF24L01();
        pinMode(motorLF, OUTPUT);
        pinMode(motorLB, OUTPUT);
        pinMode(motorRF, OUTPUT);
        pinMode(motorRB, OUTPUT);
        pinMode(pwmLSpeed, OUTPUT);
        pinMode(pwmRSpeed, OUTPUT);
        Serial.println("start");
    }
    
    void loop(void)
    {
        bool done = false;
        char i=0;
        radio.SetRX_Mode();
        delay(100);
        if(radio.nRF24L01_RxPacket(command,20)){
        if(command[3]>135 ){
            analogWrite(pwmLSpeed,(command[3]-128)*2);
            analogWrite(pwmRSpeed,(command[3]-128)*2);
            turnLeft();
            Serial.print("left:");
            Serial.println((command[3]-128)*2);
        }
        else if(command[3]<120){
            analogWrite(pwmLSpeed,(127-command[3])*2);
            analogWrite(pwmRSpeed,(127-command[3])*2);
            turnRight();
            Serial.print("right:");
            Serial.println((128-command[3])*2);
        }else if(command[4]<110){
            analogWrite(pwmLSpeed,(127-command[4])*2);
            analogWrite(pwmRSpeed,(127-command[4])*2);
            moveBackward();
            Serial.print("backward:");
            Serial.println((128-command[4])*2);
        }else if(command[4]>145){
            analogWrite(pwmLSpeed,(command[4]-128)*2);
            analogWrite(pwmRSpeed,(command[4]-128)*2);
            moveForward();
            Serial.print("forward:");
            Serial.println((command[4]-128)*2);
        }
        else{
            analogWrite(pwmLSpeed,0);
            analogWrite(pwmRSpeed,0);
            }
        Serial.println("*");
        radio.ifnnrf_CLERN_ALL();
        }
    }
    
    void turnLeft(){
        digitalWrite(motorLF,HIGH);
        digitalWrite(motorLB,LOW);
        digitalWrite(motorRF,LOW);
        digitalWrite(motorRB,HIGH);
    }
    
    void turnRight(){
        digitalWrite(motorLF,LOW);
        digitalWrite(motorLB,HIGH);
        digitalWrite(motorRF,HIGH);
        digitalWrite(motorRB,LOW);
    }
    
    void moveForward(){
        digitalWrite(motorLF,LOW);
        digitalWrite(motorLB,HIGH);
        digitalWrite(motorRF,LOW);
        digitalWrite(motorRB,HIGH);
    }
    
    void moveBackward(){
        digitalWrite(motorLF,HIGH);
        digitalWrite(motorLB,LOW);
        digitalWrite(motorRF,HIGH);
        digitalWrite(motorRB,LOW);
    }

    代码很简单,不多说,command数组保存了全部数据,其中第4、5字节为左右、前后速度控制值。

     

    展开全文
  • RF24, 面向nRF24L01Arduino驱动程序 用于 nRF24L01 2.4 GHz无线收发器的驱动程序设计目标:这个库被设计成。最大限度地符合芯片的预期操作易于初学者使用使用与其他Arduino标准库类似的public 接口根据标准SPI库...
  • 在本篇文章中,我们将主要介绍如何使用nRF24L01收发器模块在Arduino开发板和NodeMCU ESP8266模块之间进行无线通信,然后将数据上传到Thingspeak服务器,也就是实现ESP8266 nRF24L01 Wifi网关和Arduino nRF24L01节点...

    在本篇文章中,我们将主要介绍如何使用nRF24L01收发器模块在Arduino开发板和NodeMCU ESP8266模块之间进行无线通信,然后将数据上传到Thingspeak服务器,也就是实现ESP8266 nRF24L01 Wifi网关和Arduino nRF24L01节点。

    在发送器端,我们将DHT11湿度和温度传感器连接到Arduino开发板,同时连接nRF24L01收发器模块。在接收器端,我们将NodeMCU ESP8266-12E开发板与nRF24L01收发器模块连接,以实现无线显示温度和湿度数据。传感器的湿度和温度数据将上传到Thingspeak服务器上。

    所需的组件:

    ● Arduino Uno开发板

    ● DHT11湿度和温度传感器

    ● nRF24L01模块

    ● NodeMCU的ESP8266-12E

    ● 连接跳线

    ● 面包板

    nRF24L01 – 2.4GHz射频收发器模块:

    在这里插入图片描述

    这些RF模块在Arduino创客中非常受欢迎。 nRF24L01模块可用于需要无线控制的各种应用中。它们是收发器,这意味着每个模块都可以发送和接收数据。这些模块非常便宜,您可以将它们与任何微控制器(MCU)一起使用。

    nRF24L01模块的规格:

    ● 低成本单芯片2.4GHz GFSK RF收发器IC

    ● 带天线的范围:250Kb速率(开放区域)> 1000米

    ● 功耗:超低功耗

    ● 输入电压:3.3V

    ● 引脚:5V耐压

    nRF24L01模块的引脚排列:

    在这里插入图片描述

    更多内容请参考以下链接:https://www.yiboard.com/thread-1396-1-1.html


    欢迎扫码关注微信公众号:yi-board

    在这里插入图片描述

    展开全文
  • ARDUINONRF24L01无线通信

    千次阅读 2020-02-23 23:23:21
    使用的RF24库作者TMRh20 实物接线如下: 一、nRF24L01硬件连接: ...nRF24L01 Arduino UNO VCC <-> 3.3V GND <-> GND CE <-> D9 CSN <-> D10 MOSI<-> D11 MISO<-&g...
  • 在我们使用NRF24L01 2.4G无线通讯模块时往往不只是发送一个数据,这里我以我的项目总使用的6通道来分享。 使用到的材料: 两块NRF24L01模块 两块Arduino开发板(型号UNO/NANO) 杜邦线若干
  • Arduino-nrf24l01--tx-rx-project1.zip,使用NRF24L01 收发器、操纵杆模块和电机屏蔽NRF24L01--TX-RX-Project1在两个Arduinos之间进行通信的小型项目,Arduino是一家开源软硬件公司和制造商社区。Arduino始于21世纪初...
  • 文章目录 datasheet相关案例:1. Arduino开发板使用NRF24L01进行无线通信1.1 NRF24L01收发器模块1.2 NRF24L01使用说明1.3 连接示意图1.4 Arduino代码1.4.1 发射机代码1.4.2 接收机代码 1.4.3 代码描...
  • Arduino+nRF24L01无线遥控舵机和电机

    千次阅读 2020-12-17 13:29:01
    Arduino+nRF24L01无线遥控舵机和电机 哔哩哔哩视频地址:https://www.bilibili.com/video/BV1o7411F7rA/?spm_id_from=333.788.videocard.6 文章内容地址:...
  • 认识NRF24L01模块: 这是引脚 关于引脚的具体含义: CSN Chip Select Not 接收端选择引脚,Not代表低电平有效 CE Chip Enable 发射/接收状态选择引脚 MOSI Master Out Slave In 主出从...
  • 通信过程大致描述如下:树莓派通过2.4GHz廉价模块nrf24l01,发送无线数据给同样连接nrf24l01模块的Arduino模块,Arduino通过串口蓝牙将数据转发给安卓手机。 本文将分别记录以上通信实现过程,着重描述遇到的问题与...
  • 在应用nrf24l01的过程中,发现关于多对一的代码较少,也尝试过自己通过改变收发地址来实现多对一,但工作效率低数据刷新较慢,无法实现一些连续信号的实时采集,如:加速度信号。而在arduino平台下有现成的RF24...
  • arduino连接nRF24L01

    2019-09-20 06:41:55
    nRF24L01可以将多个Arduino、树莓派以及其他的单片机通过2.4GHz无线连接起来,一般都是成对使用(一个作为客户端,一个作为服务端)。例如:负责采集环境(温度、湿度、噪音等)数据的Arduino向树莓派发送数据。 ...
  • Arduino无线通信NRF24L01教程

    千次阅读 2020-01-17 06:04:16
    在本Arduino教程中,我们将学习如何使用NRF24L01收发器模块在两个Arduino板之间进行无线通信。您可以观看以下视频或阅读下面的书面教程。 Arduino无线通信NRF24L01教程 概述 为了说明无线通信,我们将举两个示例...
  • Arduino端也连接一个nRF24L01。 从Mirf的库文件中可以看到,是使用的硬件SPI,所以SCK MISO MOSI三个引脚不能修改,而另外两个引脚CE CSN可以随意更改引脚,引脚连接如下。 Pins: Hardware SPI: MISO -> 12 ...
  • 关于NRF24L01arduino有很多库,但是用和32通讯的时候遇到了问题,信道和地址一样也无法通讯,有些库也不知道怎么改信道和地址,所以直接移植了32上的代码。具体代码如下 #define uint unsigned int #define uchar ...
  • 在2015年左右DIY个人Arduino气象站时使用过nrf24l01,但代码已经丢失,特开此篇回忆一下,Arduino的学习也算告一段落,继续往STM32方向学习。 模块介绍 使用过这两种 其中下面这种是nRF24L01+PA+LNA 低噪声放大器...
  • Arduino连接nRF24L01无线收发模块

    万次阅读 多人点赞 2017-11-12 22:08:30
    Arduino连接nRF24L01无线收发模块 nRF24L01是一款工作在 2.4~2.5GHz 世界通用ISM频段的单片无线收发器芯片,输出功率、频道选择和协议的设置可以通过SPI接口进行设置。有极低的电流消耗,当工作在发射模式下...
  • Arduino 2.4G通信实验 nRF24L01模块的简单例子

    万次阅读 多人点赞 2016-11-29 13:26:31
    nRF24L01是底价的2.4G无线传输实现,可以用来做遥控哦。 输出功率频道选择和协议的设置可以通过SPI 接口进行设置。 几乎可以连接到各种单片机芯片,并完成无线数据传送工作。 极低的电流消耗:当工作在发射模式下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 510
精华内容 204
关键字:

arduinonrf24l01通信