Esp32使用nRF24L01教程

1. 
   
   
2. 
   
   
3. 
   
   
4.  

   /*
    * See documentation at https://nRF24.github.io/RF24
    * See License information at root directory of this library
    * Author: Brendan Doherty (2bndy5)
    */
   
   /**
    * A simple example of sending data from 1 nRF24L01 transceiver to another.
    *
    * This example was written to be used on 2 devices acting as "nodes".
    * Use the Serial Monitor to change each node's behavior.
    */
    /*
    接线
    NRF24L01   	  ESP32
   1	GND	          GND
   2	VCC	          3.3V
   3	(CE)	      D22
   4	(CSN)	      D21
   5	(SCK)	      D18
   6	(MOSI)	      D23
   7	(MISO)	      D19
   8	IRQ *	      D4*
   ∗: 中断线是可选的
    */
   //官网的例子
   #include <SPI.h>
   #include "printf.h"
   #include "RF24.h"
   
   // instantiate an object for the nRF24L01 transceiver
   RF24 radio(22, 21);  // using pin 7 for the CE pin, and pin 8 for the CSN pin
   
   // Let these addresses be used for the pair
   uint8_t address[][6] = { "1Node", "2Node" };
   // It is very helpful to think of an address as a path instead of as
   // an identifying device destination
   
   // to use different addresses on a pair of radios, we need a variable to
   // uniquely identify which address this radio will use to transmit
   bool radioNumber = 1;  // 0 uses address[0] to transmit, 1 uses address[1] to transmit
   
   // Used to control whether this node is sending or receiving
   bool role = false;  // true = TX role, false = RX role
   
   // For this example, we'll be using a payload containing
   // a single float number that will be incremented
   // on every successful transmission
   float payload = 0.0;
   
   void setup() {
   
     Serial.begin(115200);
     while (!Serial) {
       // some boards need to wait to ensure access to serial over USB
     }
   
     // initialize the transceiver on the SPI bus
     if (!radio.begin()) {
       Serial.println(F("radio hardware is not responding!!"));
       while (1) {}  // hold in infinite loop
     }
   
     // print example's introductory prompt
     Serial.println(F("RF24/examples/GettingStarted"));
   
     // To set the radioNumber via the Serial monitor on startup
     Serial.println(F("Which radio is this? Enter '0' or '1'. Defaults to '0'"));
     while (!Serial.available()) {
       // wait for user input
     }
     char input = Serial.parseInt();
     radioNumber = input == 1;
     Serial.print(F("radioNumber = "));
     Serial.println((int)radioNumber);
   
     // role variable is hardcoded to RX behavior, inform the user of this
     Serial.println(F("*** PRESS 'T' to begin transmitting to the other node"));
   
     // Set the PA Level low to try preventing power supply related problems
     // because these examples are likely run with nodes in close proximity to
     // each other.
     radio.setPALevel(RF24_PA_LOW);  // RF24_PA_MAX is default.
   
     // save on transmission time by setting the radio to only transmit the
     // number of bytes we need to transmit a float
     radio.setPayloadSize(sizeof(payload));  // float datatype occupies 4 bytes
   
     // set the TX address of the RX node into the TX pipe
     radio.openWritingPipe(address[radioNumber]);  // always uses pipe 0
   
     // set the RX address of the TX node into a RX pipe
     radio.openReadingPipe(1, address[!radioNumber]);  // using pipe 1
   
     // additional setup specific to the node's role
     if (role) {
       radio.stopListening();  // put radio in TX mode
     } else {
       radio.startListening();  // put radio in RX mode
     }
   
     // For debugging info
     // printf_begin();             // needed only once for printing details
     // radio.printDetails();       // (smaller) function that prints raw register values
     // radio.printPrettyDetails(); // (larger) function that prints human readable data
   
   }  // setup
   
   void loop() {
   
     if (role) {
       // This device is a TX node
   
       unsigned long start_timer = micros();                // start the timer
       bool report = radio.write(&payload, sizeof(float));  // transmit & save the report
       unsigned long end_timer = micros();                  // end the timer
   
       if (report) {
         Serial.print(F("Transmission successful! "));  // payload was delivered
         Serial.print(F("Time to transmit = "));
         Serial.print(end_timer - start_timer);  // print the timer result
         Serial.print(F(" us. Sent: "));
         Serial.println(payload);  // print payload sent
         payload += 0.01;          // increment float payload
       } else {
         Serial.println(F("Transmission failed or timed out"));  // payload was not delivered
       }
   
       // to make this example readable in the serial monitor
       delay(1000);  // slow transmissions down by 1 second
   
     } else {
       // This device is a RX node
   
       uint8_t pipe;
       if (radio.available(&pipe)) {              // is there a payload? get the pipe number that recieved it
         uint8_t bytes = radio.getPayloadSize();  // get the size of the payload
         radio.read(&payload, bytes);             // fetch payload from FIFO
         Serial.print(F("Received "));
         Serial.print(bytes);  // print the size of the payload
         Serial.print(F(" bytes on pipe "));
         Serial.print(pipe);  // print the pipe number
         Serial.print(F(": "));
         Serial.println(payload);  // print the payload's value
       }
     }  // role
   
     if (Serial.available()) {
       // change the role via the serial monitor
   
       char c = toupper(Serial.read());
       if (c == 'T' && !role) {
         // Become the TX node
   
         role = true;
         Serial.println(F("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK"));
         radio.stopListening();
   
       } else if (c == 'R' && role) {
         // Become the RX node
   
         role = false;
         Serial.println(F("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK"));
         radio.startListening();
       }
     }
   
   }  // loop
   
   
   
   
   
   
   //Esp32 + nRF24L01  与 Esp8266 + nRF24L01 通信的例子
   //ESP32作为发送端
   // SimpleTx - the master or the transmitter
   #include <Arduino.h>
   #include <SPI.h>
   #include <nRF24L01.h>
   #include <RF24.h>
   
   #define CE_PIN  22
   #define CSN_PIN 21
   
   void updateMessage(void);
   void send(void);
   
   const byte slaveAddress[5] = {'R','x','A','A','A'};
   
   
   RF24 radio(CE_PIN, CSN_PIN); // Create a Radio
   
   char dataToSend[10] = "Message 0";
   char txNum = '0';
   
   
   unsigned long currentMillis;
   unsigned long prevMillis;
   unsigned long txIntervalMillis = 1000; // send once per second
   
   
   void setup() {
   
       Serial.begin(115200);
   
       Serial.println("SimpleTx Starting");
   
       radio.begin();
       radio.setDataRate( RF24_250KBPS );
       radio.setRetries(3,5); // delay, count
       radio.openWritingPipe(slaveAddress);
   }
   
   //====================
   
   void loop() {
       currentMillis = millis();
       if (currentMillis - prevMillis >= txIntervalMillis) {
           send();
           prevMillis = millis();
       }
   }
   
   //====================
   
   void send() {
   
       bool rslt;
       rslt = radio.write( &dataToSend, sizeof(dataToSend) );
           // Always use sizeof() as it gives the size as the number of bytes.
           // For example if dataToSend was an int sizeof() would correctly return 2
   
       Serial.print("Data Sent ");
       Serial.print(dataToSend);
       if (rslt) {
           Serial.println("  Acknowledge received");
           updateMessage();
       }
       else {
           Serial.println("  Tx failed");
       }
   }
   
   //================
   
   void updateMessage() {
           // so you can see that new data is being sent
       txNum += 1;
       if (txNum > '9') {
           txNum = '0';
       }
       dataToSend[8] = txNum;
   }