Esp8266使用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.
    */
    /*
    使用RF24库
    ESP8266 与 nRF24L01接线
    
   ESP8266      nRF24L01  电源 3.3V 1GND-  2VCC引脚  8脚可不接
   D4           CE  3
   D2           CSN 4
   D5           SCK 5
   D7           MOSI 6
   D6           MISO 7
    */
   //官方的案例
   #include <SPI.h>
   #include "printf.h"
   #include "RF24.h"
   
   // instantiate an object for the nRF24L01 transceiver
   RF24 radio(D4, D2);  // 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
   
   
   
   
   
   
   //网上的ESP8266 + nRF24l01与ESP32 + nRF24l01 通信的例子 ESP8266作为接收端
   //接收端代码
   // SimpleRx - the slave or the receiver
   #include <Arduino.h>
   #include <SPI.h>
   #include <nRF24L01.h>
   #include <RF24.h>
   
   void getData(void);
   void showData(void);
   
   const byte thisSlaveAddress[5] = {'R','x','A','A','A'};
   
   RF24 radio(D4, D2);
   
   char dataReceived[10]; // this must match dataToSend in the TX
   bool newData = false;
   
   //===========
   
   void setup() {
   
       Serial.begin(115200);
   
       Serial.println("SimpleRx Starting");
       radio.begin();
       radio.setDataRate( RF24_250KBPS );
       radio.openReadingPipe(1, thisSlaveAddress);
       radio.startListening();
   }
   
   //=============
   
   void loop() {
       getData();
       showData();
   }
   
   //==============
   
   void getData() {
       if ( radio.available() ) {
           radio.read( &dataReceived, sizeof(dataReceived) );
           newData = true;
       }
   }
   
   void showData() {
       if (newData == true) {
           Serial.print("Data received ");
           Serial.println(dataReceived);
           newData = false;
       }
   }