Navigation

    makesmart

    • Registrieren
    • Anmelden
    • Suche
    • Aktuell
    • Tags
    • Kategorien
    • Ungelesen
    • Beobachtet
    • Beliebt
    • Gespeichert
    • Gruppen

    NRF24L01 mit Arduino UNO und MEGA betreiben?

    Fragen, Hilfe & Probleme
    arduino arduino ide elektrotechnik nrf24l01
    2
    3
    57
    Lade mehr Beiträge
    • Älteste zuerst
    • Neuste zuerst
    • Meiste Stimmen
    Antworten
    • In einem neuen Thema antworten
    Anmelden zum Antworten
    Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
    • J
      juli_H.05 zuletzt editiert von cooper

      Hallo Leute, erstmal Frohe Weihnachten und bleibt Gesund! Ich will zwischen 2 Mikrocontrollern wirreless kommunizieren und habe mir desshalb 2 NRF24L01 Teile geholt (¹Amazon) nun habe ich etwas rum probiert und bin noch nicht sonderlich weit gekommen. Wenn ich den Knopf drücke Leuchtet das Lämpchen leider nicht.

      Der Schaltplan:

      Empfänger code:

      #include "nRF24L01.h" // NRF24L01 library created by TMRh20 https://github.com/TMRh20/RF24
      #include "RF24.h"
      #include "SPI.h"
      
      #define LED_PIN 23
      
      int ReceivedMessage[1] = {000}; // Used to store value received by the NRF24L01
      RF24 radio(7,8); // NRF24L01 SPI pins. Pin 9 and 10 on the Nano
      
      const uint64_t pipe = 0xE6E6E6E6E6E6; // Needs to be the same for communicating between 2 NRF24L01 
      
      void setup(void)
      {
        radio.begin(); // Start the NRF24L01
        
        radio.openReadingPipe(1,pipe); // Get NRF24L01 ready to receive
        
        radio.startListening(); // Listen to see if information received
        
        pinMode(LED_PIN, OUTPUT); 
      }
      
      void loop(void)
      {
        while (radio.available())
        {
          radio.read(ReceivedMessage, 1); // Read information from the NRF24L01
      
          if (ReceivedMessage[0] == 111) // Indicates switch is pressed
          {
            digitalWrite(LED_PIN, HIGH);
          }
          else
          {
             digitalWrite(LED_PIN, LOW);
          }
          delay(2);
         }
      }
      

      Sender code

      #include "nRF24L01.h" //NRF24L01 library created by TMRh20 https://github.com/TMRh20/RF24
      #include "RF24.h"
      #include "SPI.h"
      
      #define SwitchPin 2 
      
      int SentMessage[1] = {000}; 
      RF24 radio(9,10); // NRF24L01 used SPI pins + Pin 9 and 10 on the NANO
      
      const uint64_t pipe = 0xE6E6E6E6E6E6; // Needs to be the same for communicating between 2 NRF24L01 
      
      void setup()
      {
        pinMode(SwitchPin, INPUT); 
        
        radio.begin(); // Start the NRF24L01
        radio.openWritingPipe(pipe); // Get NRF24L01 ready to transmit
      }
      
      void loop()
      {
        if (digitalRead(SwitchPin) == HIGH)    // If switch is pressed
        { 
            SentMessage[0] = 111;
            radio.write(SentMessage, 1);      // Send pressed data to NRF24L01
        }
        else 
        {
            SentMessage[0] = 000;
            radio.write(SentMessage, 1);      // Send idle data to NRF24L01
        }
      }
      

      Ich hoffe jemand kann mir helfen!

      ¹Affiliate Link. Affiliate Links sind Referenzen des Autors. Bei Kauf wird eine Provision ausgeschüttet. Mehr Informationen.

      1 Antwort Letzte Antwort Antworten Zitieren 0
      • cooper
        cooper Content Creator zuletzt editiert von cooper

        Hey, also ich habe persönlich noch nicht mit den besagten NRF24L01 gearbeitet, deswegen kann ich nur Tipps und Anregungen geben und keinen wirkliche Lösung.

        Woher hast du denn den Code? Pass den Code mal folgendermaßen an, bzw. ergänze folgendes:

        radio.begin(); // Start the NRF24L01
        
        // folgendes ergänzen nach radio.begin();
        
          if (!radio.begin()) {
            Serial.println(F("radio hardware is not responding!!"));
            while (1) {} // hold in infinite loop
          }
        

        So kannst du abfragen, ob der NRF24L01 überhaupt reagiert oder erkannt wird.


        Ansonsten wäre hier mal noch ein anderes Beispiel, aktualisiert vor ein paar Tagen, in dem ein Code für den Sender sowie Empfänger verwendet wird:

        https://github.com/nRF24/RF24/blob/master/examples/GettingStarted/GettingStarted.ino

        Für deinen Empfänger sollte der Code funktionieren, da im Sketch die gleichen Pins verwendet werden wie du sie verwendest. Für den Nano musst du die Pins dann eben anpassen.

        // instantiate an object for the nRF24L01 transceiver
        RF24 radio(7, 8); // using pin 7 for the CE pin, and pin 8 for the CSN pin
        
        /*
         * 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.
         */
        #include <SPI.h>
        #include "printf.h"
        #include "RF24.h"
        
        // instantiate an object for the nRF24L01 transceiver
        RF24 radio(7, 8); // 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
        

        Laut einigen Angaben im Internet ist es ratsam, einen Kondensator zu verwenden, um das Modul bei Peaks mit ausreichend Spannung zu versorgen.

        In der Vergangenheit gab es bei Arduino-Boards Fälle, in denen eine Spitzenspannung von mehr als 3,3V zu sehen war. Bei der Stromversorgung des Moduls direkt von einem Arduino-Board sollte daher ein 10µF Kondensator oder mehr parallel zu den VCC- und GND-Pins angeschlossen werden.

        Quelle: https://www.mikrocontroller.net/articles/NRF24L01_Tutorial


        Und ja es gibt dann neben dem NRF24L01 auch noch den NRF24L01+. Ob das beim Sketch unterschieden wird weiß ich leider nicht, da geht es aber um ein paar andere Dinge in der Datenübertragung / Abbruch / erneutes Senden bei Fail etc.

        Hoffe meine Tipps helfen dir weiter. 🙂

        1 Antwort Letzte Antwort Antworten Zitieren 0
        • J
          juli_H.05 zuletzt editiert von

          Vielen Danke @cooper für deine Antwort.
          Es tut mir leid, dass ich erst jetzt Antworten kann, da ich sehr viel Schulstress hatte.
          Das Projekt wird kurzzeitig auf Eis gelegt, da ich es momentan und in naher Zukunft noch nicht benötige.
          Ich werde aber auf jeden fall später darauf zurückkommen.

          1 Antwort Letzte Antwort Antworten Zitieren 0
          • 1 / 1
          • First post
            Last post