Move interrupt examples, add new int examples

- Create interrupts folder for RPi examples
- Add new examples
- Update Makefile

examples_RPi/Makefile

@@ -23,7 +23,7 @@ endif
 
 # define all programs
 #PROGRAMS = scanner pingtest gettingstarted
-PROGRAMS = gettingstarted gettingstarted_call_response transfer pingpair_dyn transfer_interrupt
+PROGRAMS = gettingstarted gettingstarted_call_response transfer pingpair_dyn
 SOURCES = ${PROGRAMS:=.cpp}
 
 all: ${PROGRAMS}

examples_RPi/interrupts/Makefile

+#############################################################################
+#
+# 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
+#
+prefix := /usr/local
+
+# Detect the Raspberry Pi by the existence of the bcm_host.h file
+BCMLOC=/opt/vc/include/bcm_host.h
+
+ifneq ("$(wildcard $(BCMLOC))","")
+# The recommended compiler flags for the Raspberry Pi
+CCFLAGS=-Ofast -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s
+endif
+
+# define all programs
+#PROGRAMS = scanner pingtest gettingstarted
+PROGRAMS = gettingstarted_call_response_int gettingstarted_call_response_int2 transfer_interrupt pingpair_dyn_int
+SOURCES = ${PROGRAMS:=.cpp}
+
+all: ${PROGRAMS}
+
+${PROGRAMS}: ${SOURCES}
+	g++ ${CCFLAGS} -Wall -I../ -lrf24-bcm $@.cpp -o $@
+
+clean:
+	rm -rf $(PROGRAMS)
+
+install: all
+	test -d $(prefix) || mkdir $(prefix)
+	test -d $(prefix)/bin || mkdir $(prefix)/bin
+	for prog in $(PROGRAMS); do \
+	  install -m 0755 $$prog $(prefix)/bin; \
+	done
+
+.PHONY: install

examples_RPi/interrupts/gettingstarted_call_response_int.cpp

+/*
+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
+
+

examples_RPi/interrupts/gettingstarted_call_response_int2.cpp

+/*
+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;
+volatile bool gotAck = false;
+
+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){
+    gotAck=true;
+  }
+  
+  if(role == role_ping_out && rx){
+    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
+
+    gotAck = false;
+    radio.startWrite(&counter,1,false);                         // Send the counter variable to the other radio
+        while(!gotAck){
+            if(millis()-timer > 100){break;}
+        }
+        if(!gotAck){                             // If nothing in the buffer, we got an ack but it is blank
+            printf("Got blank response. round-trip delay: %u ms\n\r",millis()-timer);
+        }
+
+
+    sleep(1);  // Try again later
+  }
+
+/****************** Pong Back Role ***************************/
+
+
+
+} //while 1
+} //main
+
+

examples_RPi/interrupts/pingpair_dyn_int.cpp

+/*
+	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);
+  }
+
+
+}
+}
+
+