初始化提交

arduino-cli/libraries/RF24/examples_linux/interrupts/Makefile

@@ -0,0 +1,24 @@
+#############################################################################
+#
+# Makefile for librf24 examples on Raspberry Pi
+#
+# License: GPL (General Public License)
+# Author:  gnulnulf <arco@appeltaart.mine.nu>
+# Date:    2013/02/07 (version 1.0)
+#
+# Description:
+# ------------
+# use make all and make install to install the examples
+# You can change the install directory by editing the prefix line
+#
+
+ifeq ($(wildcard ../../Makefile.inc), )
+    $(error Configuration not found. Run ./configure first)
+endif
+
+include ../../Makefile.inc
+
+# define all programs
+PROGRAMS = gettingstarted_call_response_int gettingstarted_call_response_int2 transfer_interrupt pingpair_dyn_int
+
+include ../Makefile.examples

arduino-cli/libraries/RF24/examples_linux/interrupts/gettingstarted_call_response_int.cpp

@@ -0,0 +1,147 @@
+/*
+TMRh20 2014 - Updated to work with optimized RF24 Arduino library
+*/
+
+
+/**
+ * Example for efficient call-response using ack-payloads and interrupts
+ *
+ * This example continues to make use of all the normal functionality of the radios including
+ * the auto-ack and auto-retry features, but allows ack-payloads to be written optionlly as well.
+ * This allows very fast call-response communication, with the responding radio never having to
+ * switch out of Primary Receiver mode to send back a payload, but having the option to switch to
+ * primary transmitter if wanting to initiate communication instead of respond to a commmunication.
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <unistd.h>
+#include <RF24/RF24.h>
+
+using namespace std;
+
+//
+// Hardware configuration
+// Configure the appropriate pins for your connections
+
+/****************** Raspberry Pi ***********************/
+
+RF24 radio(22, 0); //GPIO, SPI-BUS
+
+/********** User Config *********/
+// Assign a unique identifier for this node, 0 or 1. Arduino example uses radioNumber 0 by default.
+bool radioNumber = 1;
+int interruptPin = 23;
+/********************************/
+
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint8_t addresses[][6] = {"1Node", "2Node"};
+
+volatile bool role_ping_out = 1, role_pong_back = 0, role = 0;
+uint8_t counter = 1;                                                          // A single byte to keep track of the data being sent back and forth
+
+volatile bool gotResponse = false;
+
+void intHandler()
+{
+
+    if (role == role_pong_back) {
+        uint8_t pipeNo, gotByte;                        // Declare variables for the pipe and the byte received
+        if (radio.available(&pipeNo)) {                // Read all available payloads
+            radio.read(&gotByte, 1);
+            // Since this is a call-response. Respond directly with an ack payload.
+            gotByte += 1;                                // Ack payloads are much more efficient than switching to transmit mode to respond to a call
+            radio.writeAckPayload(pipeNo, &gotByte, 1);   // This can be commented out to send empty payloads.
+            printf("Loaded next response %d \n\r", gotByte);
+
+        }
+    }
+}
+
+int main(int argc, char** argv)
+{
+
+    cout << "RPi/RF24/examples/gettingstarted_call_response_int\n";
+    radio.begin();
+    radio.enableAckPayload();               // Allow optional ack payloads
+    radio.enableDynamicPayloads();
+    radio.printDetails();                   // Dump the configuration of the rf unit for debugging
+
+
+    /********* Role chooser ***********/
+
+    printf("\n ************ Role Setup ***********\n");
+    string input = "";
+    char myChar = {0};
+    cout << "Choose a role: Enter 0 for pong_back, 1 for ping_out (CTRL+C to exit)\n>";
+    getline(cin, input);
+
+    if (input.length() == 1) {
+        myChar = input[0];
+        if (myChar == '0') {
+            cout << "Role: Pong Back, awaiting transmission " << endl << endl;
+        } else {
+            cout << "Role: Ping Out, starting transmission " << endl << endl;
+            role = role_ping_out;
+        }
+    }
+    /***********************************/
+    // This opens two pipes for these two nodes to communicate
+    // back and forth.
+    if (!radioNumber) {
+        radio.openWritingPipe(addresses[0]);
+        radio.openReadingPipe(1, addresses[1]);
+    } else {
+        radio.openWritingPipe(addresses[1]);
+        radio.openReadingPipe(1, addresses[0]);
+    }
+    radio.startListening();
+    radio.writeAckPayload(1, &counter, 1);
+
+    radio.maskIRQ(1, 1, 0); //Mask tx_ok & tx_fail interrupts
+    attachInterrupt(interruptPin, INT_EDGE_FALLING, intHandler); //Attach interrupt to bcm pin 23
+
+    // forever loop
+    while (1) {
+
+
+        /****************** Ping Out Role ***************************/
+
+        if (role == role_ping_out) {                               // Radio is in ping mode
+
+            uint8_t gotByte;                                        // Initialize a variable for the incoming response
+
+            radio.stopListening();                                  // First, stop listening so we can talk.
+            printf("Now sending %d as payload. ", counter);          // Use a simple byte counter as payload
+            unsigned long time = millis();                          // Record the current microsecond count
+
+            if (radio.write(&counter, 1)) {                         // Send the counter variable to the other radio
+                if (!radio.available()) {                             // If nothing in the buffer, we got an ack but it is blank
+                    printf("Got blank response. round-trip delay: %lu ms\n\r", millis() - time);
+                } else {
+
+                    while (radio.available()) {                      // If an ack with payload was received
+                        radio.read(&gotByte, 1);                  // Read it, and display the response time
+                        printf("Got response %d, round-trip delay: %lu ms\n\r", gotByte, millis() - time);
+                        counter++;                                  // Increment the counter variable
+                    }
+                }
+
+            } else {
+                printf("Sending failed.\n\r");
+            }          // If no ack response, sending failed
+
+            sleep(1);  // Try again later
+        }
+
+        /****************** Pong Back Role ***************************/
+
+
+
+    } //while 1
+} //main
+
+

arduino-cli/libraries/RF24/examples_linux/interrupts/gettingstarted_call_response_int2.cpp

@@ -0,0 +1,156 @@
+/*
+TMRh20 2014 - Updated to work with optimized RF24 Arduino library
+*/
+
+
+/**
+ * Example for efficient call-response using ack-payloads
+ *
+ * This example continues to make use of all the normal functionality of the radios including
+ * the auto-ack and auto-retry features, but allows ack-payloads to be written optionlly as well.
+ * This allows very fast call-response communication, with the responding radio never having to
+ * switch out of Primary Receiver mode to send back a payload, but having the option to switch to
+ * primary transmitter if wanting to initiate communication instead of respond to a commmunication.
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <unistd.h>
+#include <RF24/RF24.h>
+
+using namespace std;
+
+//
+// Hardware configuration
+// Configure the appropriate pins for your connections
+
+/****************** Raspberry Pi ***********************/
+
+RF24 radio(22, 0);
+
+/********** User Config *********/
+// Assign a unique identifier for this node, 0 or 1. Arduino example uses radioNumber 0 by default.
+bool radioNumber = 1;
+int interruptPin = 23;
+/********************************/
+
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint8_t addresses[][6] = {"1Node", "2Node"};
+
+bool role_ping_out = 1, role_pong_back = 0, role = 0;
+uint8_t counter = 1;                                                          // A single byte to keep track of the data being sent back and forth
+uint32_t timer = 0;
+
+void intHandler()
+{
+
+    bool tx_ok, tx_fail, rx;
+    radio.whatHappened(tx_ok, tx_fail, rx);
+
+    if (tx_fail) {
+        printf("Sending failed.\n\r");
+    }
+
+    if (role == role_ping_out && tx_ok) {
+        if (!radio.available()) {
+            printf("Got blank response. round-trip delay: %u ms\n\r", millis() - timer);
+        }
+    }
+
+    if (role == role_ping_out) {
+        while (radio.available()) {
+            uint8_t gotByte;
+            radio.read(&gotByte, 1);
+            printf("Got response %d, round-trip delay: %u ms\n\r", gotByte, millis() - timer);
+            counter++;
+        }
+    }
+
+    if (role == role_pong_back) {
+        if (tx_ok) {
+            printf("Ack Payload Sent\n");
+        }
+        uint8_t pipeNo, gotByte;
+        if (radio.available(&pipeNo)) {
+            radio.read(&gotByte, 1);
+
+            gotByte += 1;
+            radio.writeAckPayload(pipeNo, &gotByte, 1);
+            printf("Loaded next response %d \n\r", gotByte);
+
+        }
+    }
+
+}
+
+int main(int argc, char** argv)
+{
+
+    cout << "RPi/RF24/examples/gettingstarted_call_response\n";
+    radio.begin();
+    radio.enableAckPayload();               // Allow optional ack payloads
+    radio.enableDynamicPayloads();
+    radio.printDetails();                   // Dump the configuration of the rf unit for debugging
+
+
+    /********* Role chooser ***********/
+
+    printf("\n ************ Role Setup ***********\n");
+    string input = "";
+    char myChar = {0};
+    cout << "Choose a role: Enter 0 for pong_back, 1 for ping_out (CTRL+C to exit)\n>";
+    getline(cin, input);
+
+    if (input.length() == 1) {
+        myChar = input[0];
+        if (myChar == '0') {
+            cout << "Role: Pong Back, awaiting transmission " << endl << endl;
+        } else {
+            cout << "Role: Ping Out, starting transmission " << endl << endl;
+            role = role_ping_out;
+        }
+    }
+    /***********************************/
+    // This opens two pipes for these two nodes to communicate
+    // back and forth.
+    if (!radioNumber) {
+        radio.openWritingPipe(addresses[0]);
+        radio.openReadingPipe(1, addresses[1]);
+    } else {
+        radio.openWritingPipe(addresses[1]);
+        radio.openReadingPipe(1, addresses[0]);
+    }
+    radio.startListening();
+    radio.writeAckPayload(1, &counter, 1);
+
+    attachInterrupt(interruptPin, INT_EDGE_FALLING, intHandler); //Attach interrupt to bcm pin 23
+
+    // forever loop
+    while (1) {
+
+
+        /****************** Ping Out Role ***************************/
+
+        if (role == role_ping_out) {                               // Radio is in ping mode
+
+            //uint8_t gotByte;                                      // Initialize a variable for the incoming response
+
+            radio.stopListening();                                  // First, stop listening so we can talk.
+            printf("Now sending %d as payload. ", counter);          // Use a simple byte counter as payload
+            timer = millis();                                       // Record the current microsecond count
+
+            radio.startWrite(&counter, 1, false);                         // Send the counter variable to the other radio
+            sleep(1);  // Try again later
+        }
+
+        /****************** Pong Back Role ***************************/
+
+
+
+    } //while 1
+} //main
+
+

arduino-cli/libraries/RF24/examples_linux/interrupts/pingpair_dyn_int.cpp

@@ -0,0 +1,177 @@
+/*
+	TMRh20 2014 - Optimized RF24 Library Fork
+*/
+
+/**
+ * Example using Dynamic Payloads
+ *
+ * This is an example of how to use payloads of a varying (dynamic) size.
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <RF24/RF24.h>
+
+using namespace std;
+//
+// Hardware configuration
+// Configure the appropriate pins for your connections
+
+/****************** Raspberry Pi ***********************/
+
+RF24 radio(22, 0); // CE GPIO, CSN SPI-BUS
+
+int interruptPin = 23; // GPIO pin for interrupts
+
+/**************************************************************/
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint64_t pipes[2] = {0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL};
+
+const int min_payload_size = 4;
+const int max_payload_size = 32;
+const int payload_size_increments_by = 1;
+int next_payload_size = min_payload_size;
+
+char receive_payload[max_payload_size + 1]; // +1 to allow room for a terminating NULL char
+bool role_ping_out = 1, role_pong_back = 0;
+bool role = 0;
+
+void intHandler()
+{
+    //
+    // Pong back role.  Receive each packet, dump it out, and send it back
+    //
+
+    if (role == role_pong_back) {
+        // if there is data ready
+        if (radio.available()) {
+            // Dump the payloads until we've gotten everything
+            uint8_t len = 0;
+
+            while (radio.available()) {
+                // Fetch the payload, and see if this was the last one.
+                len = radio.getDynamicPayloadSize();
+                radio.read(receive_payload, len);
+
+                // Put a zero at the end for easy printing
+                receive_payload[len] = 0;
+
+                // Spew it
+                printf("Got payload size=%i value=%s\n\r", len, receive_payload);
+            }
+
+            // First, stop listening so we can talk
+            radio.stopListening();
+
+            // Send the final one back.
+            radio.write(receive_payload, len);
+            printf("Sent response.\n\r");
+
+            // Now, resume listening so we catch the next packets.
+            radio.startListening();
+        }
+    }
+}
+
+int main(int argc, char** argv)
+{
+
+
+    // Print preamble:
+    cout << "RF24/examples/pingpair_dyn/\n";
+
+    // Setup and configure rf radio
+    radio.begin();
+    radio.enableDynamicPayloads();
+    radio.setRetries(5, 15);
+    radio.printDetails();
+
+
+    /********* Role chooser ***********/
+
+    printf("\n ************ Role Setup ***********\n");
+    string input = "";
+    char myChar = {0};
+    cout << "Choose a role: Enter 0 for receiver, 1 for transmitter (CTRL+C to exit) \n>";
+    getline(cin, input);
+
+    if (input.length() == 1) {
+        myChar = input[0];
+        if (myChar == '0') {
+            cout << "Role: Pong Back, awaiting transmission " << endl << endl;
+        } else {
+            cout << "Role: Ping Out, starting transmission " << endl << endl;
+            role = role_ping_out;
+        }
+    }
+    /***********************************/
+
+    if (role == role_ping_out) {
+        radio.openWritingPipe(pipes[0]);
+        radio.openReadingPipe(1, pipes[1]);
+    } else {
+        radio.openWritingPipe(pipes[1]);
+        radio.openReadingPipe(1, pipes[0]);
+        radio.startListening();
+    }
+    attachInterrupt(interruptPin, INT_EDGE_FALLING, intHandler); //Attach interrupt to bcm pin 23
+
+    // forever loop
+    while (1) {
+
+        if (role == role_ping_out) {
+            // The payload will always be the same, what will change is how much of it we send.
+            static char send_payload[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ789012";
+
+            // First, stop listening so we can talk.
+            radio.stopListening();
+
+            // Take the time, and send it.  This will block until complete
+            printf("Now sending length %i...", next_payload_size);
+            radio.write(send_payload, next_payload_size);
+
+            // Now, continue listening
+            radio.startListening();
+
+            // Wait here until we get a response, or timeout
+            unsigned long started_waiting_at = millis();
+            bool timeout = false;
+            while (!radio.available() && !timeout) {
+                if (millis() - started_waiting_at > 500) {
+                    timeout = true;
+                }
+            }
+
+            // Describe the results
+            if (timeout) {
+                printf("Failed, response timed out.\n\r");
+            } else {
+                // Grab the response, compare, and send to debugging spew
+                uint8_t len = radio.getDynamicPayloadSize();
+                radio.read(receive_payload, len);
+
+                // Put a zero at the end for easy printing
+                receive_payload[len] = 0;
+
+                // Spew it
+                printf("Got response size=%i value=%s\n\r", len, receive_payload);
+            }
+
+            // Update size for next time.
+            next_payload_size += payload_size_increments_by;
+            if (next_payload_size > max_payload_size) {
+                next_payload_size = min_payload_size;
+            }
+
+            // Try again 1s later
+            delay(100);
+        }
+
+
+    }
+}
+
+

arduino-cli/libraries/RF24/examples_linux/interrupts/transfer_interrupt.cpp

@@ -0,0 +1,190 @@
+/*
+TMRh20 2014
+
+ 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.
+ */
+
+/** General Data Transfer Rate Test
+ * This example demonstrates basic data transfer functionality with the
+ updated library. This example will display the transfer rates acheived using
+ the slower form of high-speed transfer using blocking-writes.
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <RF24/RF24.h>
+#include <unistd.h>
+
+using namespace std;
+//
+// Hardware configuration
+//
+
+/****************** Raspberry Pi ***********************/
+
+// Radio CE Pin, CSN Pin, SPI Speed
+// See http://www.airspayce.com/mikem/bcm2835/group__constants.html#ga63c029bd6500167152db4e57736d0939 and the related enumerations for pin information.
+
+// Setup for GPIO 22 CE and CE0 CSN with SPI Speed @ 4Mhz
+//RF24 radio(RPI_V2_GPIO_P1_22, BCM2835_SPI_CS0, BCM2835_SPI_SPEED_4MHZ);
+
+// NEW: Setup for RPi B+
+//RF24 radio(RPI_BPLUS_GPIO_J8_15,RPI_BPLUS_GPIO_J8_24, BCM2835_SPI_SPEED_8MHZ);
+
+// Setup for GPIO 15 CE and CE0 CSN with SPI Speed @ 8Mhz
+RF24 radio(RPI_V2_GPIO_P1_15, RPI_V2_GPIO_P1_24, BCM2835_SPI_SPEED_8MHZ);
+
+/*** RPi Alternate ***/
+//Note: Specify SPI BUS 0 or 1 instead of CS pin number.
+// See http://tmrh20.github.io/RF24/RPi.html for more information on usage
+
+//RPi Alternate, with MRAA
+//RF24 radio(15,0);
+
+//RPi Alternate, with SPIDEV - Note: Edit RF24/arch/BBB/spi.cpp and  set 'this->device = "/dev/spidev0.0";;' or as listed in /dev
+//RF24 radio(22,0);
+
+
+/****************** Linux (BBB,x86,etc) ***********************/
+
+// See http://tmrh20.github.io/RF24/pages.html for more information on usage
+// See http://iotdk.intel.com/docs/master/mraa/ for more information on MRAA
+// See https://www.kernel.org/doc/Documentation/spi/spidev for more information on SPIDEV
+
+// Setup for ARM(Linux) devices like BBB using spidev (default is "/dev/spidev1.0" )
+//RF24 radio(115,0);
+
+//BBB Alternate, with mraa
+// CE pin = (Header P9, Pin 13) = 59 = 13 + 46 
+//Note: Specify SPI BUS 0 or 1 instead of CS pin number. 
+//RF24 radio(59,0);
+
+/**************************************************************/
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint64_t addresses[2] = {0xABCDABCD71LL, 0x544d52687CLL};
+
+uint8_t data[32];
+unsigned long startTime, stopTime, counter, rxTimer = 0;
+
+void intHandler()
+{
+    //Read as long data is available
+    //Single interrupts may be lost if a lot of data comes in.
+    while (radio.available()) {
+        radio.read(&data, 32);
+        counter++;
+    }
+}
+
+int main(int argc, char** argv)
+{
+
+    bool role_ping_out = 1, role_pong_back = 0;
+    bool role = 0;
+
+    // Print preamble:
+
+    cout << "RF24/examples/Transfer/\n";
+
+    radio.begin();                           // Setup and configure rf radio
+    radio.setChannel(1);
+    radio.setPALevel(RF24_PA_MAX);
+    radio.setDataRate(RF24_1MBPS);
+    radio.setAutoAck(1);                     // Ensure autoACK is enabled
+    radio.setRetries(2, 15);                  // Optionally, increase the delay between retries & # of retries
+    radio.setCRCLength(RF24_CRC_8);          // Use 8-bit CRC for performance
+    radio.printDetails();
+    /********* Role chooser ***********/
+
+    printf("\n ************ Role Setup ***********\n");
+    string input = "";
+    char myChar = {0};
+    cout << "Choose a role: Enter 0 for receiver, 1 for transmitter (CTRL+C to exit)\n>";
+    getline(cin, input);
+
+    attachInterrupt(23, INT_EDGE_FALLING, intHandler); //Attach interrupt to bcm pin 23
+
+    if (input.length() == 1) {
+        myChar = input[0];
+        if (myChar == '0') {
+            cout << "Role: Pong Back, awaiting transmission " << endl << endl;
+        } else {
+            cout << "Role: Ping Out, starting transmission " << endl << endl;
+            role = role_ping_out;
+        }
+    }
+    /***********************************/
+
+    if (role == role_ping_out) {
+        radio.openWritingPipe(addresses[1]);
+        radio.openReadingPipe(1, addresses[0]);
+        radio.stopListening();
+    } else {
+        radio.openWritingPipe(addresses[0]);
+        radio.openReadingPipe(1, addresses[1]);
+        radio.startListening();
+    }
+
+    for (int i = 0; i < 32; i++) {
+        data[i] = rand() % 255;                        //Load the buffer with random data
+    }
+
+    // forever loop
+    while (1) {
+        if (role == role_ping_out) {
+            sleep(2);
+            printf("Initiating Basic Data Transfer\n\r");
+
+            long int cycles = 10000;                    //Change this to a higher or lower number.
+
+            // unsigned long pauseTime = millis();		//Uncomment if autoAck == 1 ( NOACK )
+            startTime = millis();
+
+            for (int i = 0; i < cycles; i++) {                //Loop through a number of cycles
+                data[0] = i;                        //Change the first byte of the payload for identification
+                if (!radio.writeFast(&data, 32)) {     //Write to the FIFO buffers
+                    counter++;                      //Keep count of failed payloads
+                }
+
+
+                //This is only required when NO ACK ( enableAutoAck(0) ) payloads are used
+                /*		if(millis() - pauseTime > 3){       // Need to drop out of TX mode every 4ms if sending a steady stream of multicast data
+                            pauseTime = millis();
+                            radio.txStandBy();				// This gives the PLL time to sync back up
+                        }
+                */
+            }
+            stopTime = millis();
+
+            if (!radio.txStandBy()) {
+                counter += 3;
+            }
+
+            float numBytes = cycles * 32;
+            float rate = numBytes / (stopTime - startTime);
+
+            printf("Transfer complete at %.2f KB/s \n\r", rate);
+            printf("%lu of %lu Packets Failed to Send\n\r", counter, cycles);
+            counter = 0;
+
+        }
+
+        if (role == role_pong_back) {
+            if (millis() - rxTimer > 1000) {
+                rxTimer = millis();
+                printf("Rate: ");
+                float numBytes = counter * 32;
+                printf("%.2f KB/s \n\r", numBytes / 1000);
+                printf("Payload Count: %lu \n\r", counter);
+                counter = 0;
+            }
+            delay(2);
+        }
+
+    } // loop
+} // main