switch to setup for Arduino Boards Manager

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/Makefile

@@ -0,0 +1,55 @@
+#############################################################################
+#
+# Makefile for librf24-bcm on Raspberry Pi
+#
+# License: GPL (General Public License)
+# Author:  Charles-Henri Hallard 
+# Date:    2013/03/13 
+#
+# Description:
+# ------------
+# use make all and mak install to install the library 
+# You can change the install directory by editing the LIBDIR line
+#
+PREFIX=/usr/local
+
+# Library parameters
+# where to put the lib
+LIBDIR=$(PREFIX)/lib
+# lib name 
+LIB=librf24-bcm
+# shared library name
+LIBNAME=$(LIB).so.1.0
+
+
+# The recommended compiler flags for the Raspberry Pi
+CCFLAGS=-Ofast -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s
+
+# make all
+# reinstall the library after each recompilation
+all: librf24-bcm install
+
+# Make the library
+librf24-bcm: RF24.o bcm2835.o 
+	g++ -shared -Wl,-soname,$@.so.1 ${CCFLAGS} -o ${LIBNAME} $^
+	
+# Library parts
+RF24.o: RF24.cpp
+	g++ -Wall -fPIC ${CCFLAGS} -c $^
+
+bcm2835.o: bcm2835.c
+	gcc -Wall -fPIC ${CCFLAGS} -c $^
+
+# clear build files
+clean:
+	rm -rf *.o ${LIB}.*
+
+# Install the library to LIBPATH
+install: 
+	@echo "[Install]"
+	@if ( test ! -d $(PREFIX)/lib ) ; then mkdir -p $(PREFIX)/lib ; fi
+	#@install -m 0755 ${LIB}.a ${LIBDIR}
+	@install -m 0755 ${LIBNAME} ${LIBDIR}
+	@ln -sf ${LIBDIR}/${LIBNAME} ${LIBDIR}/${LIB}.so.1
+	@ln -sf ${LIBDIR}/${LIBNAME} ${LIBDIR}/${LIB}.so
+	@ldconfig

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/RF24.h

@@ -0,0 +1,804 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ 
+ 03/17/2013 : Charles-Henri Hallard (http://hallard.me)
+              Modified to use with Arduipi board http://hallard.me/arduipi
+              Modified to use the great bcm2835 library for I/O and SPI
+							
+ */
+
+/**
+ * @file RF24.h
+ *
+ * Class declaration for RF24 and helper enums
+ */
+
+#ifndef __RF24_H__
+#define __RF24_H__
+
+#include "RF24_config.h"
+#include "./bcm2835.h"
+
+
+/**
+ * Power Amplifier level.
+ *
+ * For use with setPALevel()
+ */
+typedef enum { RF24_PA_MIN = 0,RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX, RF24_PA_ERROR } rf24_pa_dbm_e ;
+
+/**
+ * Data rate.  How fast data moves through the air.
+ *
+ * For use with setDataRate()
+ */
+typedef enum { RF24_1MBPS = 0, RF24_2MBPS, RF24_250KBPS } rf24_datarate_e;
+
+/**
+ * CRC Length.  How big (if any) of a CRC is included.
+ *
+ * For use with setCRCLength()
+ */
+typedef enum { RF24_CRC_DISABLED = 0, RF24_CRC_8, RF24_CRC_16 } rf24_crclength_e;
+
+/**
+ * Driver for nRF24L01(+) 2.4GHz Wireless Transceiver
+ */
+
+class RF24
+{
+private:
+  uint8_t ce_pin; /**< "Chip Enable" pin, activates the RX or TX role */
+  uint8_t csn_pin; /**< SPI Chip select */
+	uint16_t spi_speed; /**< SPI Bus Speed */
+  bool wide_band; /* 2Mbs data rate in use? */
+  bool p_variant; /* False for RF24L01 and true for RF24L01P */
+  uint8_t payload_size; /**< Fixed size of payloads */
+  bool ack_payload_available; /**< Whether there is an ack payload waiting */
+  bool dynamic_payloads_enabled; /**< Whether dynamic payloads are enabled. */ 
+  uint8_t ack_payload_length; /**< Dynamic size of pending ack payload. */
+  uint64_t pipe0_reading_address; /**< Last address set on pipe 0 for reading. */
+	//uint32_t spispeed;
+  uint8_t debug ; /* Debug flag */
+  uint8_t spi_rxbuff[32] ; //SPI receive buffer (payload max 32 bytes)
+  uint8_t spi_txbuff[32+1] ; //SPI transmit buffer (payload max 32 bytes + 1 byte for the command)
+
+protected:
+  /**
+   * @name Low-level internal interface.
+   *
+   *  Protected methods that address the chip directly.  Regular users cannot
+   *  ever call these.  They are documented for completeness and for developers who
+   *  may want to extend this class.
+   */
+  /**@{*/
+
+
+  /**
+   * Read a chunk of data in from a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param buf Where to put the data
+   * @param len How many bytes of data to transfer
+   * @return Current value of status register
+   */
+  uint8_t read_register(uint8_t reg, uint8_t* buf, uint8_t len);
+
+  /**
+   * Read single byte from a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @return Current value of register @p reg
+   */
+  uint8_t read_register(uint8_t reg);
+
+  /**
+   * Write a chunk of data to a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param buf Where to get the data
+   * @param len How many bytes of data to transfer
+   * @return Current value of status register
+   */
+  uint8_t write_register(uint8_t reg, const uint8_t* buf, uint8_t len);
+
+  /**
+   * Write a single byte to a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param value The new value to write
+   * @return Current value of status register
+   */
+  uint8_t write_register(uint8_t reg, uint8_t value);
+
+  /**
+   * Write the transmit payload
+   *
+   * The size of data written is the fixed payload size, see getPayloadSize()
+   *
+   * @param buf Where to get the data
+   * @param len Number of bytes to be sent
+   * @return Current value of status register
+   */
+  uint8_t write_payload(const void* buf, uint8_t len);
+
+  /**
+   * Read the receive payload
+   *
+   * The size of data read is the fixed payload size, see getPayloadSize()
+   *
+   * @param buf Where to put the data
+   * @param len Maximum number of bytes to read
+   * @return Current value of status register
+   */
+  uint8_t read_payload(void* buf, uint8_t len);
+
+  /**
+   * Empty the receive buffer
+   *
+   * @return Current value of status register
+   */
+  uint8_t flush_rx(void);
+
+  /**
+   * Empty the transmit buffer
+   *
+   * @return Current value of status register
+   */
+  uint8_t flush_tx(void);
+
+  /**
+   * Retrieve the current status of the chip
+   *
+   * @return Current value of status register
+   */
+  uint8_t get_status(void);
+
+  /**
+   * Decode and print the given status to stdout
+   *
+   * @param status Status value to print
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void print_status(uint8_t status);
+
+  /**
+   * Decode and print the given 'observe_tx' value to stdout
+   *
+   * @param value The observe_tx value to print
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void print_observe_tx(uint8_t value);
+
+  /**
+   * Print the name and value of an 8-bit register to stdout
+   *
+   * Optionally it can print some quantity of successive
+   * registers on the same line.  This is useful for printing a group
+   * of related registers on one line.
+   *
+   * @param name Name of the register
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param qty How many successive registers to print
+   */
+  void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1);
+
+  /**
+   * Print the name and value of a 40-bit address register to stdout
+   *
+   * Optionally it can print some quantity of successive
+   * registers on the same line.  This is useful for printing a group
+   * of related registers on one line.
+   *
+   * @param name Name of the register
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param qty How many successive registers to print
+   */
+  void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1);
+
+  /**
+   * Turn on or off the special features of the chip
+   *
+   * The chip has certain 'features' which are only available when the 'features'
+   * are enabled.  See the datasheet for details.
+   */
+  void toggle_features(void);
+  /**@}*/
+
+public:
+  /**
+   * @name Primary public interface
+   *
+   *  These are the main methods you need to operate the chip
+   */
+  /**@{*/
+
+  /**
+   * Constructor
+   *
+   * Creates a new instance of this driver.  Before using, you create an instance
+   * and send in the unique pins that this chip is connected to.
+   *
+   * @param _cepin The pin attached to Chip Enable on the RF module
+   * @param _cspin The pin attached to Chip Select
+   */
+  RF24(uint8_t _cepin, uint8_t _cspin);
+  RF24(uint8_t _cepin, uint8_t _cspin, uint32_t spispeed );
+
+  /**
+   * Begin operation of the chip
+   *
+   * Call this in setup(), before calling any other methods.
+   */
+  bool begin(void);
+
+  /**
+   * Start listening on the pipes opened for reading.
+   *
+   * Be sure to call openReadingPipe() first.  Do not call write() while
+   * in this mode, without first calling stopListening().  Call
+   * isAvailable() to check for incoming traffic, and read() to get it.
+   */
+  void startListening(void);
+
+  /**
+   * Stop listening for incoming messages
+   *
+   * Do this before calling write().
+   */
+  void stopListening(void);
+
+  /**
+   * Write to the open writing pipe
+   *
+   * Be sure to call openWritingPipe() first to set the destination
+   * of where to write to.
+   *
+   * This blocks until the message is successfully acknowledged by
+   * the receiver or the timeout/retransmit maxima are reached.  In
+   * the current configuration, the max delay here is 60ms.
+   *
+   * The maximum size of data written is the fixed payload size, see
+   * getPayloadSize().  However, you can write less, and the remainder
+   * will just be filled with zeroes.
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @return True if the payload was delivered successfully false if not
+   */
+  bool write( const void* buf, uint8_t len );
+
+  /**
+   * Test whether there are bytes available to be read
+   *
+   * @return True if there is a payload available, false if none is
+   */
+  bool available(void);
+
+  /**
+   * Read the payload
+   *
+   * Return the last payload received
+   *
+   * The size of data read is the fixed payload size, see getPayloadSize()
+   *
+   * @note I specifically chose 'void*' as a data type to make it easier
+   * for beginners to use.  No casting needed.
+   *
+   * @param buf Pointer to a buffer where the data should be written
+   * @param len Maximum number of bytes to read into the buffer
+   * @return True if the payload was delivered successfully false if not
+   */
+  bool read( void* buf, uint8_t len );
+
+  /**
+   * Open a pipe for writing
+   *
+   * Only one pipe can be open at once, but you can change the pipe
+   * you'll listen to.  Do not call this while actively listening.
+   * Remember to stopListening() first.
+   *
+   * Addresses are 40-bit hex values, e.g.:
+   *
+   * @code
+   *   openWritingPipe(0xF0F0F0F0F0);
+   * @endcode
+   *
+   * @param address The 40-bit address of the pipe to open.  This can be
+   * any value whatsoever, as long as you are the only one writing to it
+   * and only one other radio is listening to it.  Coordinate these pipe
+   * addresses amongst nodes on the network.
+   */
+  void openWritingPipe(uint64_t address);
+
+  /**
+   * Open a pipe for reading
+   *
+   * Up to 6 pipes can be open for reading at once.  Open all the
+   * reading pipes, and then call startListening().
+   *
+   * @see openWritingPipe
+   *
+   * @warning Pipes 1-5 should share the first 32 bits.
+   * Only the least significant byte should be unique, e.g.
+   * @code
+   *   openReadingPipe(1,0xF0F0F0F0AA);
+   *   openReadingPipe(2,0xF0F0F0F066);
+   * @endcode
+   *
+   * @warning Pipe 0 is also used by the writing pipe.  So if you open
+   * pipe 0 for reading, and then startListening(), it will overwrite the
+   * writing pipe.  Ergo, do an openWritingPipe() again before write().
+   *
+   * @todo Enforce the restriction that pipes 1-5 must share the top 32 bits
+   *
+   * @param number Which pipe# to open, 0-5.
+   * @param address The 40-bit address of the pipe to open.
+   */
+  void openReadingPipe(uint8_t number, uint64_t address);
+
+  /**@}*/
+  /**
+   * @name Optional Configurators 
+   *
+   *  Methods you can use to get or set the configuration of the chip.
+   *  None are required.  Calling begin() sets up a reasonable set of
+   *  defaults.
+   */
+  /**@{*/
+  /**
+   * Set the number and delay of retries upon failed submit
+   *
+   * @param delay How long to wait between each retry, in multiples of 250us,
+   * max is 15.  0 means 250us, 15 means 4000us.
+   * @param count How many retries before giving up, max 15
+   */
+  void setRetries(uint8_t delay, uint8_t count);
+
+  /**
+   * Set RF communication channel
+   *
+   * @param channel Which RF channel to communicate on, 0-127
+   */
+  void setChannel(uint8_t channel);
+
+  /**
+   * Set Static Payload Size
+   *
+   * This implementation uses a pre-stablished fixed payload size for all
+   * transmissions.  If this method is never called, the driver will always
+   * transmit the maximum payload size (32 bytes), no matter how much
+   * was sent to write().
+   *
+   * @todo Implement variable-sized payloads feature
+   *
+   * @param size The number of bytes in the payload
+   */
+  void setPayloadSize(uint8_t size);
+
+  /**
+   * Get Static Payload Size
+   *
+   * @see setPayloadSize()
+   *
+   * @return The number of bytes in the payload
+   */
+  uint8_t getPayloadSize(void);
+
+  /**
+   * Get Dynamic Payload Size
+   *
+   * For dynamic payloads, this pulls the size of the payload off
+   * the chip
+   *
+   * @return Payload length of last-received dynamic payload
+   */
+  uint8_t getDynamicPayloadSize(void);
+  
+  /**
+   * Enable custom payloads on the acknowledge packets
+   *
+   * Ack payloads are a handy way to return data back to senders without
+   * manually changing the radio modes on both units.
+   *
+   * @see examples/pingpair_pl/pingpair_pl.pde
+   */
+  void enableAckPayload(void);
+
+  /**
+   * Enable dynamically-sized payloads
+   *
+   * This way you don't always have to send large packets just to send them
+   * once in a while.  This enables dynamic payloads on ALL pipes.
+   *
+   * @see examples/pingpair_pl/pingpair_dyn.pde
+   */
+  void enableDynamicPayloads(void);
+
+  /**
+   * Determine whether the hardware is an nRF24L01+ or not.
+   *
+   * @return true if the hardware is nRF24L01+ (or compatible) and false
+   * if its not.
+   */
+  bool isPVariant(void) ;
+
+  /**
+   * Enable or disable auto-acknowlede packets
+   *
+   * This is enabled by default, so it's only needed if you want to turn
+   * it off for some reason.
+   *
+   * @param enable Whether to enable (true) or disable (false) auto-acks
+   */
+  void setAutoAck(bool enable);
+
+  /**
+   * Enable or disable auto-acknowlede packets on a per pipeline basis.
+   *
+   * AA is enabled by default, so it's only needed if you want to turn
+   * it off/on for some reason on a per pipeline basis.
+   *
+   * @param pipe Which pipeline to modify
+   * @param enable Whether to enable (true) or disable (false) auto-acks
+   */
+  void setAutoAck( uint8_t pipe, bool enable ) ;
+
+  /**
+   * Set Power Amplifier (PA) level to one of four levels.
+   * Relative mnemonics have been used to allow for future PA level
+   * changes. According to 6.5 of the nRF24L01+ specification sheet,
+   * they translate to: RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm,
+   * RF24_PA_MED=-6dBM, and RF24_PA_HIGH=0dBm.
+   *
+   * @param level Desired PA level.
+   */
+  void setPALevel( rf24_pa_dbm_e level ) ;
+
+  /**
+   * Fetches the current PA level.
+   *
+   * @return Returns a value from the rf24_pa_dbm_e enum describing
+   * the current PA setting. Please remember, all values represented
+   * by the enum mnemonics are negative dBm. See setPALevel for
+   * return value descriptions.
+   */
+  rf24_pa_dbm_e getPALevel( void ) ;
+
+  /**
+   * Set the transmission data rate
+   *
+   * @warning setting RF24_250KBPS will fail for non-plus units
+   *
+   * @param speed RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps
+   * @return true if the change was successful
+   */
+  bool setDataRate(rf24_datarate_e speed);
+  
+  /**
+   * Fetches the transmission data rate
+   *
+   * @return Returns the hardware's currently configured datarate. The value
+   * is one of 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS, as defined in the
+   * rf24_datarate_e enum.
+   */
+  rf24_datarate_e getDataRate( void ) ;
+
+  /**
+   * Set the CRC length
+   *
+   * @param length RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
+   */
+  void setCRCLength(rf24_crclength_e length);
+
+  /**
+   * Get the CRC length
+   *
+   * @return RF24_DISABLED if disabled or RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
+   */
+  rf24_crclength_e getCRCLength(void);
+
+  /**
+   * Disable CRC validation
+   *
+   */
+  void disableCRC( void ) ;
+
+  /**@}*/
+  /**
+   * @name Advanced Operation 
+   *
+   *  Methods you can use to drive the chip in more advanced ways 
+   */
+  /**@{*/
+
+  /**
+   * Print a giant block of debugging information to stdout
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void printDetails(void);
+
+  /**
+   * Enter low-power mode
+   *
+   * To return to normal power mode, either write() some data or
+   * startListening, or powerUp().
+   */
+  void powerDown(void);
+
+  /**
+   * Leave low-power mode - making radio more responsive
+   *
+   * To return to low power mode, call powerDown().
+   */
+  void powerUp(void) ;
+
+  /**
+   * Test whether there are bytes available to be read
+   *
+   * Use this version to discover on which pipe the message
+   * arrived.
+   *
+   * @param[out] pipe_num Which pipe has the payload available
+   * @return True if there is a payload available, false if none is
+   */
+  bool available(uint8_t* pipe_num);
+
+  /**
+   * Non-blocking write to the open writing pipe
+   *
+   * Just like write(), but it returns immediately. To find out what happened
+   * to the send, catch the IRQ and then call whatHappened().
+   *
+   * @see write()
+   * @see whatHappened()
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @return True if the payload was delivered successfully false if not
+   */
+  void startWrite( const void* buf, uint8_t len );
+
+  /**
+   * Write an ack payload for the specified pipe
+   *
+   * The next time a message is received on @p pipe, the data in @p buf will
+   * be sent back in the acknowledgement.
+   *
+   * @warning According to the data sheet, only three of these can be pending
+   * at any time.  I have not tested this.
+   *
+   * @param pipe Which pipe# (typically 1-5) will get this response.
+   * @param buf Pointer to data that is sent
+   * @param len Length of the data to send, up to 32 bytes max.  Not affected
+   * by the static payload set by setPayloadSize().
+   */
+  void writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
+
+  /**
+   * Determine if an ack payload was received in the most recent call to
+   * write().
+   *
+   * Call read() to retrieve the ack payload.
+   *
+   * @warning Calling this function clears the internal flag which indicates
+   * a payload is available.  If it returns true, you must read the packet
+   * out as the very next interaction with the radio, or the results are
+   * undefined.
+   *
+   * @return True if an ack payload is available.
+   */
+  bool isAckPayloadAvailable(void);
+
+  /**
+   * Call this when you get an interrupt to find out why
+   *
+   * Tells you what caused the interrupt, and clears the state of
+   * interrupts.
+   *
+   * @param[out] tx_ok The send was successful (TX_DS)
+   * @param[out] tx_fail The send failed, too many retries (MAX_RT)
+   * @param[out] rx_ready There is a message waiting to be read (RX_DS)
+   */
+  void whatHappened(bool& tx_ok,bool& tx_fail,bool& rx_ready);
+
+  /**
+   * Test whether there was a carrier on the line for the
+   * previous listening period.
+   *
+   * Useful to check for interference on the current channel.
+   *
+   * @return true if was carrier, false if not
+   */
+  bool testCarrier(void);
+
+  /**
+   * Test whether a signal (carrier or otherwise) greater than
+   * or equal to -64dBm is present on the channel. Valid only
+   * on nRF24L01P (+) hardware. On nRF24L01, use testCarrier().
+   *
+   * Useful to check for interference on the current channel and
+   * channel hopping strategies.
+   *
+   * @return true if signal => -64dBm, false if not
+   */
+  bool testRPD(void) ;
+
+  /**@}*/
+};
+
+/**
+ * @example GettingStarted.pde
+ *
+ * This is an example which corresponds to my "Getting Started" blog post:
+ * <a style="text-align:center" href="http://maniacbug.wordpress.com/2011/11/02/getting-started-rf24/">Getting Started with nRF24L01+ on Arduino</a>. 
+ *
+ * It is an example of how to use the RF24 class.  Write this sketch to two 
+ * different nodes.  Put one of the nodes into 'transmit' mode by connecting 
+ * with the serial monitor and sending a 'T'.  The ping node sends the current 
+ * time to the pong node, which responds by sending the value back.  The ping 
+ * node can then see how long the whole cycle took.
+ */
+
+/**
+ * @example nordic_fob.pde
+ *
+ * This is an example of how to use the RF24 class to receive signals from the
+ * Sparkfun Nordic FOB.  See http://www.sparkfun.com/products/8602 .
+ * Thanks to Kirk Mower for providing test hardware.
+ */
+
+/**
+ * @example led_remote.pde
+ *
+ * This is an example of how to use the RF24 class to control a remote
+ * bank of LED's using buttons on a remote control.
+ *
+ * Every time the buttons change on the remote, the entire state of
+ * buttons is send to the led board, which displays the state.
+ */
+
+/**
+ * @example pingpair.pde
+ *
+ * This is an example of how to use the RF24 class.  Write this sketch to two
+ * different nodes, connect the role_pin to ground on one.  The ping node sends
+ * the current time to the pong node, which responds by sending the value back.
+ * The ping node can then see how long the whole cycle took.
+ */
+
+/**
+ * @example pingpair_maple.pde 
+ *
+ * This is an example of how to use the RF24 class on the Maple.  For a more
+ * detailed explanation, see my blog post:
+ * <a href="http://maniacbug.wordpress.com/2011/12/14/nrf24l01-running-on-maple-3/">nRF24L01+ Running on Maple</a>
+ *
+ * It will communicate well to an Arduino-based unit as well, so it's not for only Maple-to-Maple communication.
+ * 
+ * Write this sketch to two different nodes,
+ * connect the role_pin to ground on one.  The ping node sends the current time to the pong node,
+ * which responds by sending the value back.  The ping node can then see how long the whole cycle
+ * took.
+ */
+
+/**
+ * @example starping.pde
+ *
+ * This sketch is a more complex example of using the RF24 library for Arduino.
+ * Deploy this on up to six nodes.  Set one as the 'pong receiver' by tying the
+ * role_pin low, and the others will be 'ping transmit' units.  The ping units
+ * unit will send out the value of millis() once a second.  The pong unit will
+ * respond back with a copy of the value.  Each ping unit can get that response
+ * back, and determine how long the whole cycle took.
+ *
+ * This example requires a bit more complexity to determine which unit is which.
+ * The pong receiver is identified by having its role_pin tied to ground.
+ * The ping senders are further differentiated by a byte in eeprom.
+ */
+
+/**
+ * @example pingpair_pl.pde
+ *
+ * This is an example of how to do two-way communication without changing
+ * transmit/receive modes.  Here, a payload is set to the transmitter within
+ * the Ack packet of each transmission.  Note that the payload is set BEFORE
+ * the sender's message arrives.
+ */
+
+/**
+ * @example pingpair_irq.pde
+ *
+ * This is an example of how to user interrupts to interact with the radio.
+ * It builds on the pingpair_pl example, and uses ack payloads.
+ */
+
+/**
+ * @example pingpair_sleepy.pde
+ *
+ * This is an example of how to use the RF24 class to create a battery-
+ * efficient system.  It is just like the pingpair.pde example, but the
+ * ping node powers down the radio and sleeps the MCU after every
+ * ping/pong cycle.
+ */
+
+/**
+ * @example scanner.pde
+ *
+ * Example to detect interference on the various channels available.
+ * This is a good diagnostic tool to check whether you're picking a
+ * good channel for your application.
+ *
+ * Inspired by cpixip.
+ * See http://arduino.cc/forum/index.php/topic,54795.0.html
+ */
+
+/**
+ * @mainpage Driver for nRF24L01(+) 2.4GHz Wireless Transceiver
+ *
+ * @section Goals Design Goals
+ * 
+ * This library is designed to be...
+ * @li Maximally compliant with the intended operation of the chip
+ * @li Easy for beginners to use
+ * @li Consumed with a public interface that's similiar to other Arduino standard libraries
+ *
+ * @section News News
+ * 
+ * NOW COMPATIBLE WITH ARDUINO 1.0 - The 'master' branch and all examples work with both Arduino 1.0 and earlier versions.  
+ * Please <a href="https://github.com/maniacbug/RF24/issues/new">open an issue</a> if you find any problems using it with any version of Arduino.
+ *
+ * NOW COMPATIBLE WITH MAPLE - RF24 has been tested with the 
+ * <a href="http://leaflabs.com/store/#Maple-Native">Maple Native</a>, 
+ * and should work with any Maple board.  See the pingpair_maple example.
+ * Note that only the pingpair_maple example has been tested on Maple, although
+ * the others can certainly be adapted.
+ *
+ * @section Useful Useful References
+ * 
+ * Please refer to:
+ *
+ * @li <a href="http://maniacbug.github.com/RF24/">Documentation Main Page</a>
+ * @li <a href="http://maniacbug.github.com/RF24/classRF24.html">RF24 Class Documentation</a>
+ * @li <a href="https://github.com/maniacbug/RF24/">Source Code</a>
+ * @li <a href="https://github.com/maniacbug/RF24/archives/master">Downloads Page</a>
+ * @li <a href="http://www.nordicsemi.com/files/Product/data_sheet/nRF24L01_Product_Specification_v2_0.pdf">Chip Datasheet</a>
+ *
+ * This chip uses the SPI bus, plus two chip control pins.  Remember that pin 10 must still remain an output, or
+ * the SPI hardware will go into 'slave' mode.
+ *
+ * @section More More Information
+ *
+ * @subpage FAQ
+ *
+ * @section Projects Projects
+ *
+ * Stuff I have built with RF24
+ *
+ * <img src="http://farm7.staticflickr.com/6044/6307669179_a8d19298a6_m.jpg" width="240" height="160" alt="RF24 Getting Started - Finished Product">
+ *
+ * <a style="text-align:center" href="http://maniacbug.wordpress.com/2011/11/02/getting-started-rf24/">Getting Started with nRF24L01+ on Arduino</a> 
+ *
+ * <img src="http://farm8.staticflickr.com/7159/6645514331_38eb2bdeaa_m.jpg" width="240" height="160" alt="Nordic FOB and nRF24L01+">
+ *
+ * <a style="text-align:center" href="http://maniacbug.wordpress.com/2012/01/08/nordic-fob/">Using the Sparkfun Nordic FOB</a> 
+ *
+ * <img src="http://farm7.staticflickr.com/6097/6224308836_b9b3b421a3_m.jpg" width="240" height="160" alt="RF Duinode V3 (2V4)">
+ *
+ * <a href="http://maniacbug.wordpress.com/2011/10/19/sensor-node/">Low-Power Wireless Sensor Node</a>
+ *
+ * <img src="http://farm8.staticflickr.com/7012/6489477865_b56edb629b_m.jpg" width="240" height="161" alt="nRF24L01+ connected to Leaf Labs Maple Native">
+ *
+ * <a href="http://maniacbug.wordpress.com/2011/12/14/nrf24l01-running-on-maple-3/">nRF24L01+ Running on Maple</a>
+ */
+
+#endif // __RF24_H__
+// vim:ai:cin:sts=2 sw=2 ft=cpp
+

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/RF24_config.h

@@ -0,0 +1,34 @@
+
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+  
+ 03/17/2013 : Charles-Henri Hallard (http://hallard.me)
+              Modified to use with Arduipi board http://hallard.me/arduipi
+              Modified to use the great bcm2835 library for I/O and SPI
+							
+ */
+
+#ifndef __RF24_CONFIG_H__
+#define __RF24_CONFIG_H__
+
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <sys/time.h>
+#include <stddef.h>
+#include "bcm2835.h"
+
+// GCC a Arduino Missing
+#define max(a,b) (a>b?a:b)
+#define min(a,b) (a<b?a:b)
+#define _BV(x) (1<<(x))
+#define pgm_read_word(p) (*(p))
+#define pgm_read_byte(p) (*(p))
+
+#endif // __RF24_CONFIG_H__
+// vim:ai:cin:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/examples/Makefile

@@ -0,0 +1,40 @@
+#############################################################################
+#
+# 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
+
+# The recommended compiler flags for the Raspberry Pi
+CCFLAGS=-Ofast -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s
+#CCFLAGS=
+
+# define all programs
+#PROGRAMS = scanner pingtest pongtest
+PROGRAMS = rpi-hub scanner pingtest pongtest
+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

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/examples/pingtest.cpp

@@ -0,0 +1,230 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ 
+ 03/17/2013 : Charles-Henri Hallard (http://hallard.me)
+              Modified to use with Arduipi board http://hallard.me/arduipi
+						  Changed to use modified bcm2835 and RF24 library 
+ */
+
+/**
+ * Example RF Radio Ping Pair
+ *
+ * This is an example of how to use the RF24 class.  Write this sketch to two different nodes,
+ * connect the role_pin to ground on one.  The ping node sends the current time to the pong node,
+ * which responds by sending the value back.  The ping node can then see how long the whole cycle
+ * took.
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include "./RF24.h"
+
+//
+// Hardware configuration
+//
+
+// CE Pin, CSN Pin, SPI Speed
+
+// Setup for GPIO 22 CE and GPIO 25 CSN with SPI Speed @ 1Mhz
+//RF24 radio(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_18, BCM2835_SPI_SPEED_1MHZ);
+
+// Setup for GPIO 22 CE and CE0 CSN with SPI Speed @ 4Mhz
+//RF24 radio(RPI_V2_GPIO_P1_15, BCM2835_SPI_CS0, BCM2835_SPI_SPEED_4MHZ); 
+
+// Setup for GPIO 22 CE and CE1 CSN with SPI Speed @ 8Mhz
+RF24 radio(RPI_V2_GPIO_P1_15, RPI_V2_GPIO_P1_26, BCM2835_SPI_SPEED_8MHZ);  
+
+
+// sets the role of this unit in hardware.  Connect to GND to be the 'pong' receiver
+// Leave open to be the 'ping' transmitter
+const int role_pin = 7;
+
+//
+// Topology
+//
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
+
+//
+// Role management
+//
+// Set up role.  This sketch uses the same software for all the nodes
+// in this system.  Doing so greatly simplifies testing.  The hardware itself specifies
+// which node it is.
+//
+// This is done through the role_pin
+//
+
+// The various roles supported by this sketch
+typedef enum { role_ping_out = 1, role_pong_back } role_e;
+
+// The debug-friendly names of those roles
+const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};
+
+// The role of the current running sketch
+role_e role;
+
+
+int main(int argc, char** argv)
+{
+  //
+  // Role
+  //
+
+  // set up the role 
+  role = role_ping_out;
+
+  //
+  // Print preamble:
+  //
+
+  printf("RF24/examples/pingtest/\n");
+  printf("ROLE: %s\n",role_friendly_name[role]);
+
+  //
+  // Setup and configure rf radio
+  //
+  radio.begin();
+
+  // optionally, increase the delay between retries & # of retries
+  radio.setRetries(15,15);
+
+  // optionally, reduce the payload size.  seems to
+  // improve reliability
+	//  radio.setPayloadSize(8);
+	radio.setChannel(0x4c);
+  radio.setPALevel(RF24_PA_LOW);
+
+  //
+  // Open pipes to other nodes for communication
+  //
+
+  // This simple sketch opens two pipes for these two nodes to communicate
+  // back and forth.
+  // Open 'our' pipe for writing
+  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)
+  if ( role == role_ping_out )
+  {
+    radio.openWritingPipe(pipes[0]);
+    radio.openReadingPipe(1,pipes[1]);
+  }
+  else
+  {
+    radio.openWritingPipe(pipes[1]);
+    radio.openReadingPipe(1,pipes[0]);
+  }
+
+  //
+  // Start listening
+  //
+  radio.startListening();
+
+  //
+  // Dump the configuration of the rf unit for debugging
+  //
+  radio.printDetails();
+  //
+  // Ping out role.  Repeatedly send the current time
+  //
+	
+	// forever loop
+	while (1)
+	{
+		if (role == role_ping_out)
+		{
+			// First, stop listening so we can talk.
+			radio.stopListening();
+
+			// Take the time, and send it.  This will block until complete
+			unsigned long time = millis();
+			printf("Now sending %lu...",time);
+			bool ok = radio.write( &time, sizeof(unsigned long) );
+			
+			if (ok)
+				printf("ok...");
+			else
+				printf("failed.\n");
+
+			// Now, continue listening
+			radio.startListening();
+
+			// Wait here until we get a response, or timeout (250ms)
+			unsigned long started_waiting_at = millis();
+			bool timeout = false;
+			while ( ! radio.available() && ! timeout ) {
+					// by bcatalin » Thu Feb 14, 2013 11:26 am
+					delay(5); //add a small delay to let radio.available to check payload
+				if (millis() - started_waiting_at > 200 )
+					timeout = true;
+			}
+
+
+			// Describe the results
+			if ( timeout )
+			{
+				printf("Failed, response timed out.\n");
+			}
+			else
+			{
+				// Grab the response, compare, and send to debugging spew
+				unsigned long got_time;
+				radio.read( &got_time, sizeof(unsigned long) );
+
+				// Spew it
+				printf("Got response %lu, round-trip delay: %lu\n",got_time,millis()-got_time);
+			}
+
+			// Try again 1s later
+			//    delay(1000);
+			sleep(1);
+			
+		}
+
+		//
+		// Pong back role.  Receive each packet, dump it out, and send it back
+		//
+
+		if ( role == role_pong_back )
+		{
+			// if there is data ready
+			//printf("Check available...\n");
+			if ( radio.available() )
+			{
+				// Dump the payloads until we've gotten everything
+				unsigned long got_time;
+				bool done = false;
+				
+				while (!done)
+				{
+					// Fetch the payload, and see if this was the last one.
+					done = radio.read( &got_time, sizeof(unsigned long) );
+
+					// Spew it
+					printf("Got payload(%d) %lu...\n",sizeof(unsigned long), got_time);
+
+					// Delay just a little bit to let the other unit
+					// make the transition to receiver
+					delay(20);
+				}
+
+				// First, stop listening so we can talk
+				radio.stopListening();
+
+				// Send the final one back.
+				radio.write( &got_time, sizeof(unsigned long) );
+
+				// Now, resume listening so we catch the next packets.
+				radio.startListening();
+			}
+		}
+	} // forever loop
+
+  return 0;
+}
+
+// vim:cin:ai:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/examples/pongtest.cpp

@@ -0,0 +1,229 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ 
+ 03/17/2013 : Charles-Henri Hallard (http://hallard.me)
+              Modified to use with Arduipi board http://hallard.me/arduipi
+						  Changed to use modified bcm2835 and RF24 library 
+
+ */
+
+/**
+ * Example RF Radio Ping Pair
+ *
+ * This is an example of how to use the RF24 class.  Write this sketch to two different nodes,
+ * connect the role_pin to ground on one.  The ping node sends the current time to the pong node,
+ * which responds by sending the value back.  The ping node can then see how long the whole cycle
+ * took.
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include "./RF24.h"
+
+//
+// Hardware configuration
+//
+
+// CE Pin, CSN Pin, SPI Speed
+
+// Setup for GPIO 22 CE and GPIO 25 CSN with SPI Speed @ 1Mhz
+//RF24 radio(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_18, BCM2835_SPI_SPEED_1MHZ);
+
+// Setup for GPIO 22 CE and CE0 CSN with SPI Speed @ 4Mhz
+//RF24 radio(RPI_V2_GPIO_P1_15, BCM2835_SPI_CS0, BCM2835_SPI_SPEED_4MHZ); 
+
+// Setup for GPIO 22 CE and CE1 CSN with SPI Speed @ 8Mhz
+RF24 radio(RPI_V2_GPIO_P1_15, RPI_V2_GPIO_P1_26, BCM2835_SPI_SPEED_8MHZ);  
+
+
+// sets the role of this unit in hardware.  Connect to GND to be the 'pong' receiver
+// Leave open to be the 'ping' transmitter
+const int role_pin = 7;
+
+//
+// Topology
+//
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
+
+//
+// Role management
+//
+// Set up role.  This sketch uses the same software for all the nodes
+// in this system.  Doing so greatly simplifies testing.  The hardware itself specifies
+// which node it is.
+//
+// This is done through the role_pin
+//
+
+// The various roles supported by this sketch
+typedef enum { role_ping_out = 1, role_pong_back } role_e;
+
+// The debug-friendly names of those roles
+const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};
+
+// The role of the current running sketch
+role_e role;
+
+
+int main(int argc, char** argv)
+{
+  // Role
+  role = role_pong_back;
+
+  //
+  // Print preamble:
+  //
+
+  //Serial.begin(115200);
+  //printf_begin();
+  printf("RF24/examples/pongtest/\n");
+  printf("ROLE: %s\n",role_friendly_name[role]);
+
+  //
+  // Setup and configure rf radio
+  //
+  radio.begin();
+
+  // optionally, increase the delay between retries & # of retries
+  radio.setRetries(15,15);
+
+  // optionally, reduce the payload size.  seems to
+  // improve reliability
+	//  radio.setPayloadSize(8);
+	radio.setChannel(0x4c);
+  radio.setPALevel(RF24_PA_LOW);
+
+  //
+  // Open pipes to other nodes for communication
+  //
+
+  // This simple sketch opens two pipes for these two nodes to communicate
+  // back and forth.
+  // Open 'our' pipe for writing
+  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)
+  if ( role == role_ping_out )
+  {
+    radio.openWritingPipe(pipes[0]);
+    radio.openReadingPipe(1,pipes[1]);
+  }
+  else
+  {
+    radio.openWritingPipe(pipes[1]);
+    radio.openReadingPipe(1,pipes[0]);
+  }
+
+  //
+  // Start listening
+  //
+  radio.startListening();
+
+  //
+  // Dump the configuration of the rf unit for debugging
+  //
+  radio.printDetails();
+  //
+  // Ping out role.  Repeatedly send the current time
+  //
+	
+	// forever loop
+	while (1)
+	{
+		if (role == role_ping_out)
+		{
+			// First, stop listening so we can talk.
+			radio.stopListening();
+
+			// Take the time, and send it.  This will block until complete
+			unsigned long time = millis();
+			printf("Now sending %lu...",time);
+			bool ok = radio.write( &time, sizeof(unsigned long) );
+			
+			if (ok)
+				printf("ok...");
+			else
+				printf("failed.\n");
+
+			// Now, continue listening
+			radio.startListening();
+
+			// Wait here until we get a response, or timeout (250ms)
+			unsigned long started_waiting_at = millis();
+			bool timeout = false;
+			while ( ! radio.available() && ! timeout ) {
+					// by bcatalin » Thu Feb 14, 2013 11:26 am
+					delay(5); //add a small delay to let radio.available to check payload
+				if (millis() - started_waiting_at > 200 )
+					timeout = true;
+			}
+
+
+			// Describe the results
+			if ( timeout )
+			{
+				printf("Failed, response timed out.\n");
+			}
+			else
+			{
+				// Grab the response, compare, and send to debugging spew
+				unsigned long got_time;
+				radio.read( &got_time, sizeof(unsigned long) );
+
+				// Spew it
+				printf("Got response %lu, round-trip delay: %lu\n",got_time,millis()-got_time);
+			}
+
+			// Try again 1s later
+			//    delay(1000);
+			sleep(1);
+			
+		}
+
+		//
+		// Pong back role.  Receive each packet, dump it out, and send it back
+		//
+
+		if ( role == role_pong_back )
+		{
+			// if there is data ready
+			//printf("Check available...\n");
+			if ( radio.available() )
+			{
+				// Dump the payloads until we've gotten everything
+				unsigned long got_time;
+				bool done = false;
+				
+				while (!done)
+				{
+					// Fetch the payload, and see if this was the last one.
+					done = radio.read( &got_time, sizeof(unsigned long) );
+
+					// Spew it
+					printf("Got payload(%d) %lu...\n",sizeof(unsigned long), got_time);
+
+					// Delay just a little bit to let the other unit
+					// make the transition to receiver
+					delay(20);
+				}
+
+				// First, stop listening so we can talk
+				radio.stopListening();
+
+				// Send the final one back.
+				radio.write( &got_time, sizeof(unsigned long) );
+
+				// Now, resume listening so we catch the next packets.
+				radio.startListening();
+			}
+		}
+	} // forever loop
+
+  return 0;
+}
+
+// vim:cin:ai:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/examples/rpi-hub.cpp

@@ -0,0 +1,134 @@
+/* 
+ *
+ *  Filename : rpi-hub.cpp
+ *
+ *  This program makes the RPi as a hub listening to all six pipes from the remote sensor nodes ( usually Arduino )
+ *  and will return the packet back to the sensor on pipe0 so that the sender can calculate the round trip delays
+ *  when the payload matches.
+ *  
+ *  I encounter that at times, it also receive from pipe7 ( or pipe0 ) with content of FFFFFFFFF that I will not sent
+ *  back to the sender
+ *
+ *  Refer to RF24/examples/rpi_hub_arduino/ for the corresponding Arduino sketches to work with this code.
+ * 
+ *  
+ *  CE is not used and CSN is GPIO25 (not pinout)
+ *
+ *  Refer to RPi docs for GPIO numbers
+ *
+ *  Author : Stanley Seow
+ *  e-mail : stanleyseow@gmail.com
+ *  date   : 6th Mar 2013
+ *
+ * 03/17/2013 : Charles-Henri Hallard (http://hallard.me)
+ *              Modified to use with Arduipi board http://hallard.me/arduipi
+ *						  Changed to use modified bcm2835 and RF24 library 
+ *
+ *
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include "./RF24.h"
+
+using namespace std;
+
+// Radio pipe addresses for the 2 nodes to communicate.
+// First pipe is for writing, 2nd, 3rd, 4th, 5th & 6th is for reading...
+const uint64_t pipes[6] = 
+					{ 0xF0F0F0F0D2LL, 0xF0F0F0F0E1LL, 
+						0xF0F0F0F0E2LL, 0xF0F0F0F0E3LL, 
+						0xF0F0F0F0F1, 0xF0F0F0F0F2 
+					};
+
+// CE Pin, CSN Pin, SPI Speed
+
+// Setup for GPIO 22 CE and GPIO 25 CSN with SPI Speed @ 1Mhz
+//RF24 radio(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_18, BCM2835_SPI_SPEED_1MHZ);
+
+// Setup for GPIO 22 CE and CE0 CSN with SPI Speed @ 4Mhz
+//RF24 radio(RPI_V2_GPIO_P1_15, BCM2835_SPI_CS0, BCM2835_SPI_SPEED_4MHZ); 
+
+// Setup for GPIO 22 CE and CE1 CSN with SPI Speed @ 8Mhz
+RF24 radio(RPI_V2_GPIO_P1_15, RPI_V2_GPIO_P1_26, BCM2835_SPI_SPEED_8MHZ);  
+
+
+int main(int argc, char** argv) 
+{
+	uint8_t len;
+
+	// Refer to RF24.h or nRF24L01 DS for settings
+	radio.begin();
+	radio.enableDynamicPayloads();
+	radio.setAutoAck(1);
+	radio.setRetries(15,15);
+	radio.setDataRate(RF24_1MBPS);
+	radio.setPALevel(RF24_PA_MAX);
+	radio.setChannel(76);
+	radio.setCRCLength(RF24_CRC_16);
+
+	// Open 6 pipes for readings ( 5 plus pipe0, also can be used for reading )
+	radio.openWritingPipe(pipes[0]);
+	radio.openReadingPipe(1,pipes[1]);
+	radio.openReadingPipe(2,pipes[2]);
+	radio.openReadingPipe(3,pipes[3]);
+	radio.openReadingPipe(4,pipes[4]);
+	radio.openReadingPipe(5,pipes[5]);
+
+	//
+	// Start listening
+	//
+	radio.startListening();
+
+	//
+	// Dump the configuration of the rf unit for debugging
+	//
+	radio.printDetails();
+	
+	printf("Output below : \n");
+	delay(1);
+	
+	while(1)
+	{
+		char receivePayload[32];
+		uint8_t pipe = 1;
+		
+		// Start listening
+		radio.startListening();
+					
+		while ( radio.available(&pipe) ) 
+		{
+			len = radio.getDynamicPayloadSize();
+			radio.read( receivePayload, len );
+
+			// Display it on screen
+			printf("Recv: size=%i payload=%s pipe=%i",len,receivePayload,pipe);
+
+			// Send back payload to sender
+			radio.stopListening();
+
+			// if pipe is 7, do not send it back
+			if ( pipe != 7 ) 
+			{
+				radio.write(receivePayload,len);
+				receivePayload[len]=0;
+				printf("\t Send: size=%i payload=%s pipe:%i\n",len,receivePayload,pipe);
+			}
+			else 
+			{
+				printf("\n");
+			}
+			
+			pipe++;
+			
+			// reset pipe to 0
+			if ( pipe > 6 ) 
+				pipe = 0;
+		}
+		
+		delayMicroseconds(20);
+	}
+	
+	return 0;
+}
+

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/examples/scanner.cpp

@@ -0,0 +1,146 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ 
+ 
+ 03/17/2013 : Charles-Henri Hallard (http://hallard.me)
+              Modified to use with Arduipi board http://hallard.me/arduipi
+						  Changed to use modified bcm2835 and RF24 library 
+
+ */
+
+/**
+ * Channel scanner
+ *
+ * Example to detect interference on the various channels available.
+ * This is a good diagnostic tool to check whether you're picking a
+ * good channel for your application.
+ *
+ * Inspired by cpixip.
+ * See http://arduino.cc/forum/index.php/topic,54795.0.html
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include "./RF24.h"
+
+using namespace std;
+
+//
+// Hardware configuration
+//
+
+// CE Pin, CSN Pin, SPI Speed
+
+// Setup for GPIO 22 CE and GPIO 25 CSN with SPI Speed @ 1Mhz
+//RF24 radio(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_18, BCM2835_SPI_SPEED_1MHZ);
+
+// Setup for GPIO 22 CE and CE0 CSN with SPI Speed @ 4Mhz
+//RF24 radio(RPI_V2_GPIO_P1_15, BCM2835_SPI_CS0, BCM2835_SPI_SPEED_4MHZ); 
+
+// Setup for GPIO 22 CE and CE1 CSN with SPI Speed @ 8Mhz
+RF24 radio(RPI_V2_GPIO_P1_15, RPI_V2_GPIO_P1_26, BCM2835_SPI_SPEED_8MHZ);  
+
+
+//
+// Channel info
+//
+//const uint8_t num_channels = 128;
+const uint8_t num_channels = 120;
+uint8_t values[num_channels];
+
+
+const int num_reps = 100;
+int reset_array=0;
+
+
+int main(int argc, char** argv)
+{
+  //
+  // Print preamble
+  //
+
+  //Serial.begin(57600);
+  //printf_begin();
+  printf("RF24/examples/scanner/\n");
+
+  //
+  // Setup and configure rf radio
+  //
+  radio.begin();
+	
+  radio.setAutoAck(false);
+
+  // Get into standby mode
+  radio.startListening();
+  radio.stopListening();
+
+  radio.printDetails();
+
+  // Print out header, high then low digit
+  int i = 0;
+	
+  while ( i < num_channels )
+  {
+    printf("%x",i>>4);
+    ++i;
+  }
+  printf("\n");
+	
+  i = 0;
+  while ( i < num_channels )
+  {
+    printf("%x",i&0xf);
+    ++i;
+  }
+  printf("\n");       
+	
+	// forever loop
+  while(1)
+	{
+		if ( reset_array == 1 )
+		{	
+			// Clear measurement values
+			memset(values,0,sizeof(values));
+			printf("\n");
+		}
+
+		// Scan all channels num_reps times
+		int i = num_channels;
+		while (i--)
+		{
+			// Select this channel
+			radio.setChannel(i);
+
+			// Listen for a little
+			radio.startListening();
+			delayMicroseconds(128);
+			radio.stopListening();
+
+			// Did we get a carrier?
+			if ( radio.testCarrier() )
+					++values[i];
+			if ( values[i] == 0xf ) 
+			{
+				reset_array = 2;
+			}
+		}
+
+		// Print out channel measurements, clamped to a single hex digit
+		i = 0;
+		while ( i < num_channels )
+		{
+			printf("%x",min(0xf,(values[i]&0xf)));
+			++i;
+		}
+		
+		printf("\n");
+	}
+	
+  return 0;
+}
+
+// vim:ai:cin:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/nRF24L01.h

@@ -0,0 +1,125 @@
+/*
+    Copyright (c) 2007 Stefan Engelke <mbox@stefanengelke.de>
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation 
+    files (the "Software"), to deal in the Software without 
+    restriction, including without limitation the rights to use, copy, 
+    modify, merge, publish, distribute, sublicense, and/or sell copies 
+    of the Software, and to permit persons to whom the Software is 
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be 
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+    DEALINGS IN THE SOFTWARE.
+*/
+
+/* Memory Map */
+#define CONFIG      0x00
+#define EN_AA       0x01
+#define EN_RXADDR   0x02
+#define SETUP_AW    0x03
+#define SETUP_RETR  0x04
+#define RF_CH       0x05
+#define RF_SETUP    0x06
+#define STATUS      0x07
+#define OBSERVE_TX  0x08
+#define CD          0x09
+#define RX_ADDR_P0  0x0A
+#define RX_ADDR_P1  0x0B
+#define RX_ADDR_P2  0x0C
+#define RX_ADDR_P3  0x0D
+#define RX_ADDR_P4  0x0E
+#define RX_ADDR_P5  0x0F
+#define TX_ADDR     0x10
+#define RX_PW_P0    0x11
+#define RX_PW_P1    0x12
+#define RX_PW_P2    0x13
+#define RX_PW_P3    0x14
+#define RX_PW_P4    0x15
+#define RX_PW_P5    0x16
+#define FIFO_STATUS 0x17
+#define DYNPD	    0x1C
+#define FEATURE	    0x1D
+
+/* Bit Mnemonics */
+#define MASK_RX_DR  6
+#define MASK_TX_DS  5
+#define MASK_MAX_RT 4
+#define EN_CRC      3
+#define CRCO        2
+#define PWR_UP      1
+#define PRIM_RX     0
+#define ENAA_P5     5
+#define ENAA_P4     4
+#define ENAA_P3     3
+#define ENAA_P2     2
+#define ENAA_P1     1
+#define ENAA_P0     0
+#define ERX_P5      5
+#define ERX_P4      4
+#define ERX_P3      3
+#define ERX_P2      2
+#define ERX_P1      1
+#define ERX_P0      0
+#define AW          0
+#define ARD         4
+#define ARC         0
+#define PLL_LOCK    4
+#define RF_DR       3
+#define RF_PWR      6
+#define RX_DR       6
+#define TX_DS       5
+#define MAX_RT      4
+#define RX_P_NO     1
+#define TX_FULL     0
+#define PLOS_CNT    4
+#define ARC_CNT     0
+#define TX_REUSE    6
+#define FIFO_FULL   5
+#define TX_EMPTY    4
+#define RX_FULL     1
+#define RX_EMPTY    0
+#define DPL_P5	    5
+#define DPL_P4	    4
+#define DPL_P3	    3
+#define DPL_P2	    2
+#define DPL_P1	    1
+#define DPL_P0	    0
+#define EN_DPL	    2
+#define EN_ACK_PAY  1
+#define EN_DYN_ACK  0
+
+/* Instruction Mnemonics */
+#define R_REGISTER    0x00
+#define W_REGISTER    0x20
+#define REGISTER_MASK 0x1F
+#define ACTIVATE      0x50
+#define R_RX_PL_WID   0x60
+#define R_RX_PAYLOAD  0x61
+#define W_TX_PAYLOAD  0xA0
+#define W_ACK_PAYLOAD 0xA8
+#define FLUSH_TX      0xE1
+#define FLUSH_RX      0xE2
+#define REUSE_TX_PL   0xE3
+#define NOP           0xFF
+
+/* Non-P omissions */
+#define LNA_HCURR   0
+
+/* P model memory Map */
+#define RPD         0x09
+
+/* P model bit Mnemonics */
+#define RF_DR_LOW   5
+#define RF_DR_HIGH  3
+#define RF_PWR_LOW  1
+#define RF_PWR_HIGH 2

digistump-sam/libraries/RF24/librf24-rpi/librf24-bcm/readme.md

@@ -0,0 +1,49 @@
+this is library to use the nrf24l01 on the raspberry pi.
+
+it's based on the arduino lib from J. Coliz <maniacbug@ymail.com>.
+the library was berryfied by Purinda Gunasekara <purinda@gmail.com>.
+then forked from forked from github stanleyseow/RF24 by myself
+
+setup the library
+=================
+
+Clone or download this repo then go to folder
+cd RF24/librf24-rpi/librf24-bcm/
+
+then 
+
+make ; make install
+
+examples
+========
+
+go to examples subfolder then 
+make ; make install
+
+In my examples I used the NRF on ArduiPi Board 
+http://hallard.me/arduipi
+
+So on example file the instance is created as follow, change the pins according your connections
+
+// Setup for GPIO 22 CE and CE1 CSN with SPI Speed @ 8Mhz
+RF24 radio(RPI_V2_GPIO_P1_15, RPI_V2_GPIO_P1_26, BCM2835_SPI_SPEED_8MHZ);  
+
+
+Pin are
+NRF24L01    RPI       P1 Connector
+nrf-vcc  = rpi-3v3        (01)
+nrf-gnd  = rpi-gnd        (06)
+nrf-ce   = rpi-ce1        (26)
+nrf-csn  = rpi-gpio22     (15)
+nrf-sck  = rpi-sckl       (23)
+nrf-mo   = rpi-mosi       (19)
+nrf-mi   = rpi-miso       (21)
+
+known issues
+============
+none
+
+contact
+=======
+Charles-Henri Hallard http://hallard.me
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/Makefile

@@ -0,0 +1,51 @@
+#############################################################################
+#
+# Makefile for librf24 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 mak install to install the library 
+# You can change the install directory by editing the LIBDIR line
+#
+LIBDIR=/usr/local/lib
+LIBNAME=librf24.so.1.0
+
+
+# The recommended compiler flags for the Raspberry Pi
+CCFLAGS=-Ofast -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s
+
+# make all
+all: librf24
+
+# Make the library
+librf24: RF24.o gpio.o spi.o compatibility.o
+	g++ -shared -Wl,-soname,librf24.so.1 ${CCFLAGS}  -o ${LIBNAME} compatibility.o gpio.o spi.o RF24.o
+
+# Library parts
+RF24.o: RF24.cpp
+	g++ -Wall -fPIC ${CCFLAGS} -c RF24.cpp
+
+gpio.o: gpio.cpp
+	g++ -Wall -fPIC ${CCFLAGS} -c gpio.cpp
+
+spi.o: spi.cpp
+	g++ -Wall -fPIC ${CCFLAGS} -c spi.cpp
+
+compatibility.o: compatibility.c
+	gcc -Wall -fPIC  ${CCFLAGS} -c compatibility.c
+
+# clear build files
+clean:
+	rm -rf *o ${LIBNAME}
+
+# Install the library to LIBPATH
+install: 
+	cp librf24.so.1.0 ${LIBDIR}/${LIBNAME}
+	ln -sf ${LIBDIR}/${LIBNAME} ${LIBDIR}/librf24.so.1
+	ln -sf ${LIBDIR}/${LIBNAME} ${LIBDIR}/librf24.so
+	ldconfig
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/RF24.h

@@ -0,0 +1,824 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ */
+
+/**
+ * @file RF24.h
+ *
+ * Class declaration for RF24 and helper enums
+ */
+
+#ifndef __RF24_H__
+#define __RF24_H__
+
+#include "RF24_config.h"
+//#include "lib/RF24/compatibility.h"
+#include "compatibility.h"
+
+/**
+ * Power Amplifier level.
+ *
+ * For use with setPALevel()
+ */
+typedef enum { RF24_PA_MIN = 0,RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX, RF24_PA_ERROR } rf24_pa_dbm_e ;
+
+/**
+ * Data rate.  How fast data moves through the air.
+ *
+ * For use with setDataRate()
+ */
+typedef enum { RF24_1MBPS = 0, RF24_2MBPS, RF24_250KBPS } rf24_datarate_e;
+
+/**
+ * CRC Length.  How big (if any) of a CRC is included.
+ *
+ * For use with setCRCLength()
+ */
+typedef enum { RF24_CRC_DISABLED = 0, RF24_CRC_8, RF24_CRC_16 } rf24_crclength_e;
+
+/**
+ * Driver for nRF24L01(+) 2.4GHz Wireless Transceiver
+ */
+
+class RF24
+{
+private:
+  uint8_t ce_pin; /**< "Chip Enable" pin, activates the RX or TX role, unused on rpi */
+  string spidevice;
+  uint32_t spispeed;
+  uint8_t csn_pin; /**< SPI Chip select */
+  bool wide_band; /* 2Mbs data rate in use? */
+  bool p_variant; /* False for RF24L01 and true for RF24L01P */
+  uint8_t payload_size; /**< Fixed size of payloads */
+  bool ack_payload_available; /**< Whether there is an ack payload waiting */
+  bool dynamic_payloads_enabled; /**< Whether dynamic payloads are enabled. */ 
+  uint8_t ack_payload_length; /**< Dynamic size of pending ack payload. */
+  uint64_t pipe0_reading_address; /**< Last address set on pipe 0 for reading. */
+
+  SPI* spi;
+  
+protected:
+  /**
+   * @name Low-level internal interface.
+   *
+   *  Protected methods that address the chip directly.  Regular users cannot
+   *  ever call these.  They are documented for completeness and for developers who
+   *  may want to extend this class.
+   */
+  /**@{*/
+
+  /**
+   * Set chip select pin
+   *
+   * Running SPI bus at PI_CLOCK_DIV2 so we don't waste time transferring data
+   * and best of all, we make use of the radio's FIFO buffers. A lower speed
+   * means we're less likely to effectively leverage our FIFOs and pay a higher
+   * AVR runtime cost as toll.
+   *
+   * @param mode HIGH to take this unit off the SPI bus, LOW to put it on
+   */
+  void csn(int mode);
+
+  /**
+   * Set chip enable
+   *
+   * @param level HIGH to actively begin transmission or LOW to put in standby.  Please see data sheet
+   * for a much more detailed description of this pin.
+   */
+  void ce(int level);
+
+  /**
+   * Read a chunk of data in from a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param buf Where to put the data
+   * @param len How many bytes of data to transfer
+   * @return Current value of status register
+   */
+  uint8_t read_register(uint8_t reg, uint8_t* buf, uint8_t len);
+
+  /**
+   * Read single byte from a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @return Current value of register @p reg
+   */
+  uint8_t read_register(uint8_t reg);
+
+  /**
+   * Write a chunk of data to a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param buf Where to get the data
+   * @param len How many bytes of data to transfer
+   * @return Current value of status register
+   */
+  uint8_t write_register(uint8_t reg, const uint8_t* buf, uint8_t len);
+
+  /**
+   * Write a single byte to a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param value The new value to write
+   * @return Current value of status register
+   */
+  uint8_t write_register(uint8_t reg, uint8_t value);
+
+  /**
+   * Write the transmit payload
+   *
+   * The size of data written is the fixed payload size, see getPayloadSize()
+   *
+   * @param buf Where to get the data
+   * @param len Number of bytes to be sent
+   * @return Current value of status register
+   */
+  uint8_t write_payload(const void* buf, uint8_t len);
+
+  /**
+   * Read the receive payload
+   *
+   * The size of data read is the fixed payload size, see getPayloadSize()
+   *
+   * @param buf Where to put the data
+   * @param len Maximum number of bytes to read
+   * @return Current value of status register
+   */
+  uint8_t read_payload(void* buf, uint8_t len);
+
+  /**
+   * Empty the receive buffer
+   *
+   * @return Current value of status register
+   */
+  uint8_t flush_rx(void);
+
+  /**
+   * Empty the transmit buffer
+   *
+   * @return Current value of status register
+   */
+  uint8_t flush_tx(void);
+
+  /**
+   * Retrieve the current status of the chip
+   *
+   * @return Current value of status register
+   */
+  uint8_t get_status(void);
+
+  /**
+   * Decode and print the given status to stdout
+   *
+   * @param status Status value to print
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void print_status(uint8_t status);
+
+  /**
+   * Decode and print the given 'observe_tx' value to stdout
+   *
+   * @param value The observe_tx value to print
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void print_observe_tx(uint8_t value);
+
+  /**
+   * Print the name and value of an 8-bit register to stdout
+   *
+   * Optionally it can print some quantity of successive
+   * registers on the same line.  This is useful for printing a group
+   * of related registers on one line.
+   *
+   * @param name Name of the register
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param qty How many successive registers to print
+   */
+  void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1);
+
+  /**
+   * Print the name and value of a 40-bit address register to stdout
+   *
+   * Optionally it can print some quantity of successive
+   * registers on the same line.  This is useful for printing a group
+   * of related registers on one line.
+   *
+   * @param name Name of the register
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param qty How many successive registers to print
+   */
+  void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1);
+
+  /**
+   * Turn on or off the special features of the chip
+   *
+   * The chip has certain 'features' which are only available when the 'features'
+   * are enabled.  See the datasheet for details.
+   */
+  void toggle_features(void);
+  /**@}*/
+
+public:
+  /**
+   * @name Primary public interface
+   *
+   *  These are the main methods you need to operate the chip
+   */
+  /**@{*/
+
+  /**
+   * Constructor
+   *
+   * Creates a new instance of this driver.  Before using, you create an instance
+   * and send in the unique pins that this chip is connected to.
+   *
+   * @param _cepin The pin attached to Chip Enable on the RF module
+   * @param _cspin The pin attached to Chip SPI chipSelect
+   */
+  RF24(uint8_t _cepin, uint8_t _cspin);
+  RF24(string _spidevice, uint32_t _spispeed, uint8_t _cepin);
+
+  /**
+   * Begin operation of the chip
+   *
+   * Call this in setup(), before calling any other methods.
+   */
+  void begin(void);
+
+ /**
+   * Reset confguration of the chip
+   *
+   * Call this to reset all registers
+   */
+  void resetcfg(void);
+
+  /**
+   * Start listening on the pipes opened for reading.
+   *
+   * Be sure to call openReadingPipe() first.  Do not call write() while
+   * in this mode, without first calling stopListening().  Call
+   * isAvailable() to check for incoming traffic, and read() to get it.
+   */
+  void startListening(void);
+
+  /**
+   * Stop listening for incoming messages
+   *
+   * Do this before calling write().
+   */
+  void stopListening(void);
+
+  /**
+   * Write to the open writing pipe
+   *
+   * Be sure to call openWritingPipe() first to set the destination
+   * of where to write to.
+   *
+   * This blocks until the message is successfully acknowledged by
+   * the receiver or the timeout/retransmit maxima are reached.  In
+   * the current configuration, the max delay here is 60ms.
+   *
+   * The maximum size of data written is the fixed payload size, see
+   * getPayloadSize().  However, you can write less, and the remainder
+   * will just be filled with zeroes.
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @return True if the payload was delivered successfully false if not
+   */
+  bool write( const void* buf, uint8_t len );
+
+  /**
+   * Test whether there are bytes available to be read
+   *
+   * @return True if there is a payload available, false if none is
+   */
+  bool available(void);
+
+  /**
+   * Read the payload
+   *
+   * Return the last payload received
+   *
+   * The size of data read is the fixed payload size, see getPayloadSize()
+   *
+   * @note I specifically chose 'void*' as a data type to make it easier
+   * for beginners to use.  No casting needed.
+   *
+   * @param buf Pointer to a buffer where the data should be written
+   * @param len Maximum number of bytes to read into the buffer
+   * @return True if the payload was delivered successfully false if not
+   */
+  bool read( void* buf, uint8_t len );
+
+  /**
+   * Open a pipe for writing
+   *
+   * Only one pipe can be open at once, but you can change the pipe
+   * you'll listen to.  Do not call this while actively listening.
+   * Remember to stopListening() first.
+   *
+   * Addresses are 40-bit hex values, e.g.:
+   *
+   * @code
+   *   openWritingPipe(0xF0F0F0F0F0);
+   * @endcode
+   *
+   * @param address The 40-bit address of the pipe to open.  This can be
+   * any value whatsoever, as long as you are the only one writing to it
+   * and only one other radio is listening to it.  Coordinate these pipe
+   * addresses amongst nodes on the network.
+   */
+  void openWritingPipe(uint64_t address);
+
+  /**
+   * Open a pipe for reading
+   *
+   * Up to 6 pipes can be open for reading at once.  Open all the
+   * reading pipes, and then call startListening().
+   *
+   * @see openWritingPipe
+   *
+   * @warning Pipes 1-5 should share the first 32 bits.
+   * Only the least significant byte should be unique, e.g.
+   * @code
+   *   openReadingPipe(1,0xF0F0F0F0AA);
+   *   openReadingPipe(2,0xF0F0F0F066);
+   * @endcode
+   *
+   * @warning Pipe 0 is also used by the writing pipe.  So if you open
+   * pipe 0 for reading, and then startListening(), it will overwrite the
+   * writing pipe.  Ergo, do an openWritingPipe() again before write().
+   *
+   * @todo Enforce the restriction that pipes 1-5 must share the top 32 bits
+   *
+   * @param number Which pipe# to open, 0-5.
+   * @param address The 40-bit address of the pipe to open.
+   */
+  void openReadingPipe(uint8_t number, uint64_t address);
+
+  /**@}*/
+  /**
+   * @name Optional Configurators 
+   *
+   *  Methods you can use to get or set the configuration of the chip.
+   *  None are required.  Calling begin() sets up a reasonable set of
+   *  defaults.
+   */
+  /**@{*/
+  /**
+   * Set the number and delay of retries upon failed submit
+   *
+   * @param delay How long to wait between each retry, in multiples of 250us,
+   * max is 15.  0 means 250us, 15 means 4000us.
+   * @param count How many retries before giving up, max 15
+   */
+  void setRetries(uint8_t delay, uint8_t count);
+
+  /**
+   * Set RF communication channel
+   *
+   * @param channel Which RF channel to communicate on, 0-127
+   */
+  void setChannel(uint8_t channel);
+
+  /**
+   * Set Static Payload Size
+   *
+   * This implementation uses a pre-stablished fixed payload size for all
+   * transmissions.  If this method is never called, the driver will always
+   * transmit the maximum payload size (32 bytes), no matter how much
+   * was sent to write().
+   *
+   * @todo Implement variable-sized payloads feature
+   *
+   * @param size The number of bytes in the payload
+   */
+  void setPayloadSize(uint8_t size);
+
+  /**
+   * Get Static Payload Size
+   *
+   * @see setPayloadSize()
+   *
+   * @return The number of bytes in the payload
+   */
+  uint8_t getPayloadSize(void);
+
+  /**
+   * Get Dynamic Payload Size
+   *
+   * For dynamic payloads, this pulls the size of the payload off
+   * the chip
+   *
+   * @return Payload length of last-received dynamic payload
+   */
+  uint8_t getDynamicPayloadSize(void);
+  
+  /**
+   * Enable custom payloads on the acknowledge packets
+   *
+   * Ack payloads are a handy way to return data back to senders without
+   * manually changing the radio modes on both units.
+   *
+   * @see examples/pingpair_pl/pingpair_pl.pde
+   */
+  void enableAckPayload(void);
+
+  /**
+   * Enable dynamically-sized payloads
+   *
+   * This way you don't always have to send large packets just to send them
+   * once in a while.  This enables dynamic payloads on ALL pipes.
+   *
+   * @see examples/pingpair_pl/pingpair_dyn.pde
+   */
+  void enableDynamicPayloads(void);
+
+  /**
+   * Determine whether the hardware is an nRF24L01+ or not.
+   *
+   * @return true if the hardware is nRF24L01+ (or compatible) and false
+   * if its not.
+   */
+  bool isPVariant(void) ;
+
+  /**
+   * Enable or disable auto-acknowlede packets
+   *
+   * This is enabled by default, so it's only needed if you want to turn
+   * it off for some reason.
+   *
+   * @param enable Whether to enable (true) or disable (false) auto-acks
+   */
+  void setAutoAck(bool enable);
+
+  /**
+   * Enable or disable auto-acknowlede packets on a per pipeline basis.
+   *
+   * AA is enabled by default, so it's only needed if you want to turn
+   * it off/on for some reason on a per pipeline basis.
+   *
+   * @param pipe Which pipeline to modify
+   * @param enable Whether to enable (true) or disable (false) auto-acks
+   */
+  void setAutoAck( uint8_t pipe, bool enable ) ;
+
+  /**
+   * Set Power Amplifier (PA) level to one of four levels.
+   * Relative mnemonics have been used to allow for future PA level
+   * changes. According to 6.5 of the nRF24L01+ specification sheet,
+   * they translate to: RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm,
+   * RF24_PA_MED=-6dBM, and RF24_PA_HIGH=0dBm.
+   *
+   * @param level Desired PA level.
+   */
+  void setPALevel( rf24_pa_dbm_e level ) ;
+
+  /**
+   * Fetches the current PA level.
+   *
+   * @return Returns a value from the rf24_pa_dbm_e enum describing
+   * the current PA setting. Please remember, all values represented
+   * by the enum mnemonics are negative dBm. See setPALevel for
+   * return value descriptions.
+   */
+  rf24_pa_dbm_e getPALevel( void ) ;
+
+  /**
+   * Set the transmission data rate
+   *
+   * @warning setting RF24_250KBPS will fail for non-plus units
+   *
+   * @param speed RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps
+   * @return true if the change was successful
+   */
+  bool setDataRate(rf24_datarate_e speed);
+  
+  /**
+   * Fetches the transmission data rate
+   *
+   * @return Returns the hardware's currently configured datarate. The value
+   * is one of 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS, as defined in the
+   * rf24_datarate_e enum.
+   */
+  rf24_datarate_e getDataRate( void ) ;
+
+  /**
+   * Set the CRC length
+   *
+   * @param length RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
+   */
+  void setCRCLength(rf24_crclength_e length);
+
+  /**
+   * Get the CRC length
+   *
+   * @return RF24_DISABLED if disabled or RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
+   */
+  rf24_crclength_e getCRCLength(void);
+
+  /**
+   * Disable CRC validation
+   *
+   */
+  void disableCRC( void ) ;
+
+  /**@}*/
+  /**
+   * @name Advanced Operation 
+   *
+   *  Methods you can use to drive the chip in more advanced ways 
+   */
+  /**@{*/
+
+  /**
+   * Print a giant block of debugging information to stdout
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void printDetails(void);
+
+  /**
+   * Enter low-power mode
+   *
+   * To return to normal power mode, either write() some data or
+   * startListening, or powerUp().
+   */
+  void powerDown(void);
+
+  /**
+   * Leave low-power mode - making radio more responsive
+   *
+   * To return to low power mode, call powerDown().
+   */
+  void powerUp(void) ;
+
+  /**
+   * Test whether there are bytes available to be read
+   *
+   * Use this version to discover on which pipe the message
+   * arrived.
+   *
+   * @param[out] pipe_num Which pipe has the payload available
+   * @return True if there is a payload available, false if none is
+   */
+  bool available(uint8_t* pipe_num);
+
+  /**
+   * Non-blocking write to the open writing pipe
+   *
+   * Just like write(), but it returns immediately. To find out what happened
+   * to the send, catch the IRQ and then call whatHappened().
+   *
+   * @see write()
+   * @see whatHappened()
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @return True if the payload was delivered successfully false if not
+   */
+  void startWrite( const void* buf, uint8_t len );
+
+  /**
+   * Write an ack payload for the specified pipe
+   *
+   * The next time a message is received on @p pipe, the data in @p buf will
+   * be sent back in the acknowledgement.
+   *
+   * @warning According to the data sheet, only three of these can be pending
+   * at any time.  I have not tested this.
+   *
+   * @param pipe Which pipe# (typically 1-5) will get this response.
+   * @param buf Pointer to data that is sent
+   * @param len Length of the data to send, up to 32 bytes max.  Not affected
+   * by the static payload set by setPayloadSize().
+   */
+  void writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
+
+  /**
+   * Determine if an ack payload was received in the most recent call to
+   * write().
+   *
+   * Call read() to retrieve the ack payload.
+   *
+   * @warning Calling this function clears the internal flag which indicates
+   * a payload is available.  If it returns true, you must read the packet
+   * out as the very next interaction with the radio, or the results are
+   * undefined.
+   *
+   * @return True if an ack payload is available.
+   */
+  bool isAckPayloadAvailable(void);
+
+  /**
+   * Call this when you get an interrupt to find out why
+   *
+   * Tells you what caused the interrupt, and clears the state of
+   * interrupts.
+   *
+   * @param[out] tx_ok The send was successful (TX_DS)
+   * @param[out] tx_fail The send failed, too many retries (MAX_RT)
+   * @param[out] rx_ready There is a message waiting to be read (RX_DS)
+   */
+  void whatHappened(bool& tx_ok,bool& tx_fail,bool& rx_ready);
+
+  /**
+   * Test whether there was a carrier on the line for the
+   * previous listening period.
+   *
+   * Useful to check for interference on the current channel.
+   *
+   * @return true if was carrier, false if not
+   */
+  bool testCarrier(void);
+
+  /**
+   * Test whether a signal (carrier or otherwise) greater than
+   * or equal to -64dBm is present on the channel. Valid only
+   * on nRF24L01P (+) hardware. On nRF24L01, use testCarrier().
+   *
+   * Useful to check for interference on the current channel and
+   * channel hopping strategies.
+   *
+   * @return true if signal => -64dBm, false if not
+   */
+  bool testRPD(void) ;
+
+  /**@}*/
+};
+
+/**
+ * @example GettingStarted.pde
+ *
+ * This is an example which corresponds to my "Getting Started" blog post:
+ * <a style="text-align:center" href="http://maniacbug.wordpress.com/2011/11/02/getting-started-rf24/">Getting Started with nRF24L01+ on Arduino</a>. 
+ *
+ * It is an example of how to use the RF24 class.  Write this sketch to two 
+ * different nodes.  Put one of the nodes into 'transmit' mode by connecting 
+ * with the serial monitor and sending a 'T'.  The ping node sends the current 
+ * time to the pong node, which responds by sending the value back.  The ping 
+ * node can then see how long the whole cycle took.
+ */
+
+/**
+ * @example nordic_fob.pde
+ *
+ * This is an example of how to use the RF24 class to receive signals from the
+ * Sparkfun Nordic FOB.  See http://www.sparkfun.com/products/8602 .
+ * Thanks to Kirk Mower for providing test hardware.
+ */
+
+/**
+ * @example led_remote.pde
+ *
+ * This is an example of how to use the RF24 class to control a remote
+ * bank of LED's using buttons on a remote control.
+ *
+ * Every time the buttons change on the remote, the entire state of
+ * buttons is send to the led board, which displays the state.
+ */
+
+/**
+ * @example pingpair.pde
+ *
+ * This is an example of how to use the RF24 class.  Write this sketch to two
+ * different nodes, connect the role_pin to ground on one.  The ping node sends
+ * the current time to the pong node, which responds by sending the value back.
+ * The ping node can then see how long the whole cycle took.
+ */
+
+/**
+ * @example pingpair_maple.pde 
+ *
+ * This is an example of how to use the RF24 class on the Maple.  For a more
+ * detailed explanation, see my blog post:
+ * <a href="http://maniacbug.wordpress.com/2011/12/14/nrf24l01-running-on-maple-3/">nRF24L01+ Running on Maple</a>
+ *
+ * It will communicate well to an Arduino-based unit as well, so it's not for only Maple-to-Maple communication.
+ * 
+ * Write this sketch to two different nodes,
+ * connect the role_pin to ground on one.  The ping node sends the current time to the pong node,
+ * which responds by sending the value back.  The ping node can then see how long the whole cycle
+ * took.
+ */
+
+/**
+ * @example starping.pde
+ *
+ * This sketch is a more complex example of using the RF24 library for Arduino.
+ * Deploy this on up to six nodes.  Set one as the 'pong receiver' by tying the
+ * role_pin low, and the others will be 'ping transmit' units.  The ping units
+ * unit will send out the value of millis() once a second.  The pong unit will
+ * respond back with a copy of the value.  Each ping unit can get that response
+ * back, and determine how long the whole cycle took.
+ *
+ * This example requires a bit more complexity to determine which unit is which.
+ * The pong receiver is identified by having its role_pin tied to ground.
+ * The ping senders are further differentiated by a byte in eeprom.
+ */
+
+/**
+ * @example pingpair_pl.pde
+ *
+ * This is an example of how to do two-way communication without changing
+ * transmit/receive modes.  Here, a payload is set to the transmitter within
+ * the Ack packet of each transmission.  Note that the payload is set BEFORE
+ * the sender's message arrives.
+ */
+
+/**
+ * @example pingpair_irq.pde
+ *
+ * This is an example of how to user interrupts to interact with the radio.
+ * It builds on the pingpair_pl example, and uses ack payloads.
+ */
+
+/**
+ * @example pingpair_sleepy.pde
+ *
+ * This is an example of how to use the RF24 class to create a battery-
+ * efficient system.  It is just like the pingpair.pde example, but the
+ * ping node powers down the radio and sleeps the MCU after every
+ * ping/pong cycle.
+ */
+
+/**
+ * @example scanner.pde
+ *
+ * Example to detect interference on the various channels available.
+ * This is a good diagnostic tool to check whether you're picking a
+ * good channel for your application.
+ *
+ * Inspired by cpixip.
+ * See http://arduino.cc/forum/index.php/topic,54795.0.html
+ */
+
+/**
+ * @mainpage Driver for nRF24L01(+) 2.4GHz Wireless Transceiver
+ *
+ * @section Goals Design Goals
+ * 
+ * This library is designed to be...
+ * @li Maximally compliant with the intended operation of the chip
+ * @li Easy for beginners to use
+ * @li Consumed with a public interface that's similiar to other Arduino standard libraries
+ *
+ * @section News News
+ * 
+ * NOW COMPATIBLE WITH ARDUINO 1.0 - The 'master' branch and all examples work with both Arduino 1.0 and earlier versions.  
+ * Please <a href="https://github.com/maniacbug/RF24/issues/new">open an issue</a> if you find any problems using it with any version of Arduino.
+ *
+ * NOW COMPATIBLE WITH MAPLE - RF24 has been tested with the 
+ * <a href="http://leaflabs.com/store/#Maple-Native">Maple Native</a>, 
+ * and should work with any Maple board.  See the pingpair_maple example.
+ * Note that only the pingpair_maple example has been tested on Maple, although
+ * the others can certainly be adapted.
+ *
+ * @section Useful Useful References
+ * 
+ * Please refer to:
+ *
+ * @li <a href="http://maniacbug.github.com/RF24/">Documentation Main Page</a>
+ * @li <a href="http://maniacbug.github.com/RF24/classRF24.html">RF24 Class Documentation</a>
+ * @li <a href="https://github.com/maniacbug/RF24/">Source Code</a>
+ * @li <a href="https://github.com/maniacbug/RF24/archives/master">Downloads Page</a>
+ * @li <a href="http://www.nordicsemi.com/files/Product/data_sheet/nRF24L01_Product_Specification_v2_0.pdf">Chip Datasheet</a>
+ *
+ * This chip uses the SPI bus, plus two chip control pins.  Remember that pin 10 must still remain an output, or
+ * the SPI hardware will go into 'slave' mode.
+ *
+ * @section More More Information
+ *
+ * @subpage FAQ
+ *
+ * @section Projects Projects
+ *
+ * Stuff I have built with RF24
+ *
+ * <img src="http://farm7.staticflickr.com/6044/6307669179_a8d19298a6_m.jpg" width="240" height="160" alt="RF24 Getting Started - Finished Product">
+ *
+ * <a style="text-align:center" href="http://maniacbug.wordpress.com/2011/11/02/getting-started-rf24/">Getting Started with nRF24L01+ on Arduino</a> 
+ *
+ * <img src="http://farm8.staticflickr.com/7159/6645514331_38eb2bdeaa_m.jpg" width="240" height="160" alt="Nordic FOB and nRF24L01+">
+ *
+ * <a style="text-align:center" href="http://maniacbug.wordpress.com/2012/01/08/nordic-fob/">Using the Sparkfun Nordic FOB</a> 
+ *
+ * <img src="http://farm7.staticflickr.com/6097/6224308836_b9b3b421a3_m.jpg" width="240" height="160" alt="RF Duinode V3 (2V4)">
+ *
+ * <a href="http://maniacbug.wordpress.com/2011/10/19/sensor-node/">Low-Power Wireless Sensor Node</a>
+ *
+ * <img src="http://farm8.staticflickr.com/7012/6489477865_b56edb629b_m.jpg" width="240" height="161" alt="nRF24L01+ connected to Leaf Labs Maple Native">
+ *
+ * <a href="http://maniacbug.wordpress.com/2011/12/14/nrf24l01-running-on-maple-3/">nRF24L01+ Running on Maple</a>
+ */
+
+#endif // __RF24_H__
+// vim:ai:cin:sts=2 sw=2 ft=cpp
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/RF24_config.h

@@ -0,0 +1,103 @@
+
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ */
+
+#ifndef __RF24_CONFIG_H__
+#define __RF24_CONFIG_H__
+
+
+#ifdef ARDUINO
+//#warning "Arduino enabled"
+#if ARDUINO < 100
+//#include <WProgram.h>
+#else
+//#include <Arduino.h>
+#endif
+#else 
+//#warning "Arduino disabled"
+#include "spi.h"
+#include "gpio.h"
+#include "compatibility.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <sys/time.h>
+
+#define pgm_read_word(p) (*(p))
+#define pgm_read_byte(p) (*(p))
+#endif
+
+#include <stddef.h>
+
+// Stuff that is normally provided by Arduino
+//#ifdef ARDUINO
+//#include <SPI.h>
+//#else
+//#include <stdint.h>
+//#//include <stdio.h>
+//#include <string.h>
+//extern HardwareSPI SPI;
+//#define _BV(x) (1<<(x))
+
+//#else 
+//#endif
+
+//#include "../spi/spi.h"
+//#include "../gpio/gpio.h"
+
+#define _BV(x) (1<<(x))
+
+// #endif
+
+#undef SERIAL_DEBUG
+#ifdef SERIAL_DEBUG
+#define IF_SERIAL_DEBUG(x) ({x;})
+#else
+#define IF_SERIAL_DEBUG(x)
+#endif
+
+// Avoid spurious warnings
+#if 1
+#if ! defined( NATIVE ) && defined( ARDUINO )
+#undef PROGMEM
+#define PROGMEM __attribute__(( section(".progmem.data") ))
+#undef PSTR
+#define PSTR(s) (__extension__({static const char __c[] PROGMEM = (s); &__c[0];}))
+#endif
+#endif
+
+// Progmem is Arduino-specific
+//#ifdef ARDUINO
+//#include <avr/pgmspace.h>
+//#define PRIPSTR "%S"
+//#else
+//typedef char const char;
+typedef uint16_t prog_uint16_t;
+#define PSTR(x) (x)
+#define printf_P printf
+#define strlen_P strlen
+#define PROGMEM
+#define pgm_read_word(p) (*(p)) 
+#define PRIPSTR "%s"
+
+
+// Function, constant map as a result of migrating from Arduino
+#define LOW GPIO::OUTPUT_LOW
+#define HIGH GPIO::OUTPUT_HIGH
+#define INPUT GPIO::DIRECTION_IN
+#define OUTPUT GPIO::DIRECTION_OUT
+#define digitalWrite(pin, value) GPIO::write(pin, value)
+#define pinMode(pin, direction) GPIO::open(pin, direction)
+#define delay(milisec) __msleep(milisec)
+#define delayMicroseconds(usec) __usleep(usec)
+
+//#endif
+
+#endif // __RF24_CONFIG_H__
+// vim:ai:cin:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24/compatibility.c

@@ -0,0 +1,40 @@
+
+#include "compatibility.h"
+/**********************************************************************/
+/**
+ * This function is added in order to simulate arduino delay() function
+ * @param milisec
+ */
+void __msleep(int milisec)
+{
+	struct timespec req = {0};
+	req.tv_sec = 0;
+	req.tv_nsec = milisec * 1000000L;
+	nanosleep(&req, (struct timespec *)NULL);	
+}
+
+void __usleep(int milisec)
+{
+	struct timespec req = {0};
+	req.tv_sec = 0;
+	req.tv_nsec = milisec * 1000L;
+	nanosleep(&req, (struct timespec *)NULL);	
+}
+
+/**
+ * This function is added in order to simulate arduino millis() function
+ */
+void __start_timer()
+{
+	gettimeofday(&start, NULL);
+}
+
+long __millis()
+{
+	gettimeofday(&end, NULL);
+    seconds  = end.tv_sec  - start.tv_sec;
+    useconds = end.tv_usec - start.tv_usec;
+
+    mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;	
+	return mtime;
+}

digistump-sam/libraries/RF24/librf24-rpi/librf24/compatibility.h

@@ -0,0 +1,36 @@
+/* 
+ * File:   compatiblity.h
+ * Author: purinda
+ *
+ * Created on 24 June 2012, 3:08 PM
+ */
+
+#ifndef COMPATIBLITY_H
+#define	COMPATIBLITY_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+	
+#include <stddef.h>
+#include <time.h>
+#include <sys/time.h>
+
+// added attribute unused to avoid compiler warnings
+static struct timeval start __attribute__ ((unused)) ,end __attribute__ ((unused));
+
+static long __attribute__ ((unused)) mtime;
+static long __attribute__ ((unused)) seconds;
+static long __attribute__ ((unused)) useconds;
+
+void __msleep(int milisec);
+void __usleep(int milisec);
+void __start_timer();
+long __millis();
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* COMPATIBLITY_H */
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/examples/Makefile

@@ -0,0 +1,41 @@
+#############################################################################
+#
+# 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 := /opt/librf24-examples
+
+# The recommended compiler flags for the Raspberry Pi
+CCFLAGS=-Wall -Ofast -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s
+#CCFLAGS=
+
+# define all programs
+#PROGRAMS = scanner pingtest pongtest
+PROGRAMS = rpi-hub scanner pingtest pongtest
+SOURCES = ${PROGRAMS:=.cpp}
+
+all: ${PROGRAMS}
+
+${PROGRAMS}: ${SOURCES}
+#	g++ ${CCFLAGS} -Wall -L../librf24/  -lrf24 $@.cpp -o $@
+	g++ ${CCFLAGS} -L../librf24/  -lrf24 $@.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

digistump-sam/libraries/RF24/librf24-rpi/librf24/examples/pingtest.cpp

@@ -0,0 +1,239 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ */
+
+/**
+ * Example RF Radio Ping Pair
+ *
+ * This is an example of how to use the RF24 class.  Write this sketch to two different nodes,
+ * connect the role_pin to ground on one.  The ping node sends the current time to the pong node,
+ * which responds by sending the value back.  The ping node can then see how long the whole cycle
+ * took.
+ */
+
+#include <cstdlib>
+#include <iostream>
+
+#include "../RF24.h"
+
+//
+// Hardware configuration
+//
+
+// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
+
+//RF24 radio(9,10);
+RF24 radio("/dev/spidev0.0",8000000 , 25);  //spi device, speed and CSN,only CSN is NEEDED in RPI
+
+
+// sets the role of this unit in hardware.  Connect to GND to be the 'pong' receiver
+// Leave open to be the 'ping' transmitter
+const int role_pin = 7;
+
+//
+// Topology
+//
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
+
+//
+// Role management
+//
+// Set up role.  This sketch uses the same software for all the nodes
+// in this system.  Doing so greatly simplifies testing.  The hardware itself specifies
+// which node it is.
+//
+// This is done through the role_pin
+//
+
+// The various roles supported by this sketch
+typedef enum { role_ping_out = 1, role_pong_back } role_e;
+
+// The debug-friendly names of those roles
+const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};
+
+// The role of the current running sketch
+role_e role;
+
+void setup(void)
+{
+  //
+  // Role
+  //
+
+  // set up the role pin
+ // pinMode(role_pin, INPUT);
+  //digitalWrite(role_pin,HIGH);
+ // delay(20); // Just to get a solid reading on the role pin
+
+  // read the address pin, establish our role
+  //if ( ! digitalRead(role_pin) )
+    role = role_ping_out;
+  //else
+  //  role = role_pong_back;
+
+  //
+  // Print preamble:
+  //
+
+  //Serial.begin(115200);
+  //printf_begin();
+  printf("\n\rRF24/examples/pingpair/\n\r");
+  printf("ROLE: %s\n\r",role_friendly_name[role]);
+
+  //
+  // Setup and configure rf radio
+  //
+
+  radio.begin();
+
+  // optionally, increase the delay between retries & # of retries
+  radio.setRetries(15,15);
+
+  // optionally, reduce the payload size.  seems to
+  // improve reliability
+//  radio.setPayloadSize(8);
+ radio.setChannel(0x4c);
+     radio.setPALevel(RF24_PA_MAX);
+
+  //
+  // Open pipes to other nodes for communication
+  //
+
+  // This simple sketch opens two pipes for these two nodes to communicate
+  // back and forth.
+  // Open 'our' pipe for writing
+  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)
+
+  if ( role == role_ping_out )
+  {
+    radio.openWritingPipe(pipes[0]);
+    radio.openReadingPipe(1,pipes[1]);
+  }
+  else
+  {
+    radio.openWritingPipe(pipes[1]);
+    radio.openReadingPipe(1,pipes[0]);
+  }
+
+  //
+  // Start listening
+  //
+
+  radio.startListening();
+
+  //
+  // Dump the configuration of the rf unit for debugging
+  //
+
+  radio.printDetails();
+}
+
+void loop(void)
+{
+  //
+  // Ping out role.  Repeatedly send the current time
+  //
+
+  if (role == role_ping_out)
+  {
+    // First, stop listening so we can talk.
+    radio.stopListening();
+
+    // Take the time, and send it.  This will block until complete
+    unsigned long time = __millis();
+    printf("Now sending %lu...",time);
+    bool ok = radio.write( &time, sizeof(unsigned long) );
+    
+    if (ok)
+      printf("ok...");
+    else
+      printf("failed.\n\r");
+
+    // Now, continue listening
+    radio.startListening();
+
+    // Wait here until we get a response, or timeout (250ms)
+    unsigned long started_waiting_at = __millis();
+    bool timeout = false;
+    while ( ! radio.available() && ! timeout ) {
+	// by bcatalin » Thu Feb 14, 2013 11:26 am 
+	__msleep(5); //add a small delay to let radio.available to check payload
+      if (__millis() - started_waiting_at > 200 )
+        timeout = true;
+    }
+
+    // Describe the results
+    if ( timeout )
+    {
+      printf("Failed, response timed out.\n\r");
+    }
+    else
+    {
+      // Grab the response, compare, and send to debugging spew
+      unsigned long got_time;
+      radio.read( &got_time, sizeof(unsigned long) );
+
+      // Spew it
+      printf("Got response %lu, round-trip delay: %lu\n\r",got_time,__millis()-got_time);
+    }
+
+    // Try again 1s later
+//    delay(1000);
+sleep(1);
+  }
+
+  //
+  // 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
+      unsigned long got_time;
+      bool done = false;
+      while (!done)
+      {
+        // Fetch the payload, and see if this was the last one.
+        done = radio.read( &got_time, sizeof(unsigned long) );
+
+        // Spew it
+        printf("Got payload %lu...",got_time);
+
+	// Delay just a little bit to let the other unit
+	// make the transition to receiver
+	delay(20);
+      }
+
+      // First, stop listening so we can talk
+      radio.stopListening();
+
+      // Send the final one back.
+      printf("Sent response.\n\r");
+      radio.write( &got_time, sizeof(unsigned long) );
+
+      // Now, resume listening so we catch the next packets.
+      radio.startListening();
+    }
+  }
+}
+
+int main(int argc, char** argv)
+{
+        setup();
+        while(1)
+                loop();
+
+        return 0;
+}
+
+
+// vim:cin:ai:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24/examples/pongtest.cpp

@@ -0,0 +1,240 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ */
+
+/**
+ * Example RF Radio Ping Pair
+ *
+ * This is an example of how to use the RF24 class.  Write this sketch to two different nodes,
+ * connect the role_pin to ground on one.  The ping node sends the current time to the pong node,
+ * which responds by sending the value back.  The ping node can then see how long the whole cycle
+ * took.
+ */
+
+#include <cstdlib>
+#include <iostream>
+
+#include "../RF24.h"
+
+//
+// Hardware configuration
+//
+
+// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
+
+//RF24 radio(9,10);
+RF24 radio("/dev/spidev0.0",2000000 , 25);  //spi device, speed and CE,only CE is NEEDED in RPI
+
+
+// sets the role of this unit in hardware.  Connect to GND to be the 'pong' receiver
+// Leave open to be the 'ping' transmitter
+const int role_pin = 7;
+
+//
+// Topology
+//
+
+// Radio pipe addresses for the 2 nodes to communicate.
+const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
+
+//
+// Role management
+//
+// Set up role.  This sketch uses the same software for all the nodes
+// in this system.  Doing so greatly simplifies testing.  The hardware itself specifies
+// which node it is.
+//
+// This is done through the role_pin
+//
+
+// The various roles supported by this sketch
+typedef enum { role_ping_out = 1, role_pong_back } role_e;
+
+// The debug-friendly names of those roles
+const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};
+
+// The role of the current running sketch
+role_e role;
+
+void setup(void)
+{
+  //
+  // Role
+  //
+
+  // set up the role pin
+ // pinMode(role_pin, INPUT);
+  //digitalWrite(role_pin,HIGH);
+ // delay(20); // Just to get a solid reading on the role pin
+
+  // read the address pin, establish our role
+  //if ( ! digitalRead(role_pin) )
+  //  role = role_ping_out;
+  //else
+    role = role_pong_back;
+
+  //
+  // Print preamble:
+  //
+
+  //Serial.begin(115200);
+  //printf_begin();
+  printf("\n\rRF24/examples/pingpair/\n\r");
+  printf("ROLE: %s\n\r",role_friendly_name[role]);
+
+  //
+  // Setup and configure rf radio
+  //
+
+  radio.begin();
+
+  // optionally, increase the delay between retries & # of retries
+  radio.setRetries(15,15);
+
+  // optionally, reduce the payload size.  seems to
+  // improve reliability
+//  radio.setPayloadSize(8);
+ radio.setChannel(0x4c);
+     radio.setPALevel(RF24_PA_LOW);
+
+  //
+  // Open pipes to other nodes for communication
+  //
+
+  // This simple sketch opens two pipes for these two nodes to communicate
+  // back and forth.
+  // Open 'our' pipe for writing
+  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)
+
+  if ( role == role_ping_out )
+  {
+    radio.openWritingPipe(pipes[0]);
+    radio.openReadingPipe(1,pipes[1]);
+  }
+  else
+  {
+    radio.openWritingPipe(pipes[1]);
+    radio.openReadingPipe(1,pipes[0]);
+  }
+
+  //
+  // Start listening
+  //
+
+  radio.startListening();
+
+  //
+  // Dump the configuration of the rf unit for debugging
+  //
+
+  radio.printDetails();
+}
+
+void loop(void)
+{
+  //
+  // Ping out role.  Repeatedly send the current time
+  //
+
+  if (role == role_ping_out)
+  {
+    // First, stop listening so we can talk.
+    radio.stopListening();
+
+    // Take the time, and send it.  This will block until complete
+    unsigned long time = __millis();
+    printf("Now sending %lu...",time);
+    bool ok = radio.write( &time, sizeof(unsigned long) );
+    
+    if (ok)
+      printf("ok...");
+    else
+      printf("failed.\n\r");
+
+    // Now, continue listening
+    radio.startListening();
+
+    // Wait here until we get a response, or timeout (250ms)
+    unsigned long started_waiting_at = __millis();
+    bool timeout = false;
+    while ( ! radio.available() && ! timeout ) {
+        // by bcatalin » Thu Feb 14, 2013 11:26 am
+        __msleep(5); //add a small delay to let radio.available to check payload
+      if (__millis() - started_waiting_at > 200 )
+        timeout = true;
+    }
+
+
+    // Describe the results
+    if ( timeout )
+    {
+      printf("Failed, response timed out.\n\r");
+    }
+    else
+    {
+      // Grab the response, compare, and send to debugging spew
+      unsigned long got_time;
+      radio.read( &got_time, sizeof(unsigned long) );
+
+      // Spew it
+      printf("Got response %lu, round-trip delay: %lu\n\r",got_time,__millis()-got_time);
+    }
+
+    // Try again 1s later
+//    delay(1000);
+sleep(1);
+  }
+
+  //
+  // 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
+      unsigned long got_time;
+      bool done = false;
+      while (!done)
+      {
+        // Fetch the payload, and see if this was the last one.
+        done = radio.read( &got_time, sizeof(unsigned long) );
+
+        // Spew it
+        printf("Got payload %lu...",got_time);
+
+	// Delay just a little bit to let the other unit
+	// make the transition to receiver
+	delay(20);
+      }
+
+      // First, stop listening so we can talk
+      radio.stopListening();
+
+      // Send the final one back.
+      printf("Sent response.\n\r");
+      radio.write( &got_time, sizeof(unsigned long) );
+
+      // Now, resume listening so we catch the next packets.
+      radio.startListening();
+    }
+  }
+}
+
+int main(int argc, char** argv)
+{
+        setup();
+        while(1)
+                loop();
+
+        return 0;
+}
+
+
+// vim:cin:ai:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24/examples/rpi-hub.cpp

@@ -0,0 +1,119 @@
+/* 
+ *
+ *  Filename : rpi-hub.cpp
+ *
+ *  This program makes the RPi as a hub listening to all six pipes from the remote sensor nodes ( usually Arduino )
+ *  and will return the packet back to the sensor on pipe0 so that the sender can calculate the round trip delays
+ *  when the payload matches.
+ *  
+ *  I encounter that at times, it also receive from pipe7 ( or pipe0 ) with content of FFFFFFFFF that I will not sent
+ *  back to the sender
+ *
+ *  Refer to RF24/examples/rpi_hub_arduino/ for the corresponding Arduino sketches to work with this code.
+ * 
+ *  
+ *  CE is not used and CSN is GPIO25 (not pinout)
+ *
+ *  Refer to RPi docs for GPIO numbers
+ *
+ *  Author : Stanley Seow
+ *  e-mail : stanleyseow@gmail.com
+ *  date   : 6th Mar 2013
+ *
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include "../RF24.h"
+
+using namespace std;
+
+// Radio pipe addresses for the 2 nodes to communicate.
+// First pipe is for writing, 2nd, 3rd, 4th, 5th & 6th is for reading...
+const uint64_t pipes[6] = { 0xF0F0F0F0D2LL, 0xF0F0F0F0E1LL, 0xF0F0F0F0E2LL, 0xF0F0F0F0E3LL, 0xF0F0F0F0F1, 0xF0F0F0F0F2 };
+
+// CE and CSN pins On header using GPIO numbering (not pin numbers)
+RF24 radio("/dev/spidev0.0",8000000,25);  // Setup for GPIO 25 CSN
+
+
+void setup(void)
+{
+	//
+	// Refer to RF24.h or nRF24L01 DS for settings
+	radio.begin();
+	radio.enableDynamicPayloads();
+	radio.setAutoAck(1);
+	radio.setRetries(15,15);
+	radio.setDataRate(RF24_1MBPS);
+	radio.setPALevel(RF24_PA_MAX);
+	radio.setChannel(76);
+	radio.setCRCLength(RF24_CRC_16);
+
+	// Open 6 pipes for readings ( 5 plus pipe0, also can be used for reading )
+	radio.openWritingPipe(pipes[0]);
+	radio.openReadingPipe(1,pipes[1]);
+	radio.openReadingPipe(2,pipes[2]);
+	radio.openReadingPipe(3,pipes[3]);
+	radio.openReadingPipe(4,pipes[4]);
+	radio.openReadingPipe(5,pipes[5]);
+
+	//
+	// Start listening
+	//
+
+	radio.startListening();
+
+	//
+	// Dump the configuration of the rf unit for debugging
+	//
+
+	radio.printDetails();
+	printf("\n\rOutput below : \n\r");
+	usleep(1000);
+}
+
+void loop(void)
+{
+	char receivePayload[32];
+	uint8_t pipe = 1;
+	
+	// Start listening
+	radio.startListening();
+
+        
+	 while ( radio.available(&pipe) ) {
+
+		uint8_t len = radio.getDynamicPayloadSize();
+		radio.read( receivePayload, len );
+
+		// Display it on screen
+		printf("Recv: size=%i payload=%s pipe=%i",len,receivePayload,pipe);
+
+		// Send back payload to sender
+		radio.stopListening();
+
+		// if pipe is 7, do not send it back
+		if ( pipe != 7 ) {
+			radio.write(receivePayload,len);
+			receivePayload[len]=0;
+			printf("\t Send: size=%i payload=%s pipe:%i\n\r",len,receivePayload,pipe);
+		} else {
+			printf("\n\r");
+                }
+		pipe++;
+		// reset pipe to 0
+		if ( pipe > 6 ) pipe = 0;
+	}
+	usleep(20);
+}
+
+
+int main(int argc, char** argv) 
+{
+	setup();
+	while(1)
+		loop();
+	
+	return 0;
+}
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/examples/scanner.cpp

@@ -0,0 +1,189 @@
+/*
+ Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
+
+ 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.
+ */
+
+/**
+ * Channel scanner
+ *
+ * Example to detect interference on the various channels available.
+ * This is a good diagnostic tool to check whether you're picking a
+ * good channel for your application.
+ *
+ * Inspired by cpixip.
+ * See http://arduino.cc/forum/index.php/topic,54795.0.html
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include "../RF24.h"
+
+using namespace std;
+
+//
+// Hardware configuration
+//
+
+// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
+
+// CE and CSN pins 
+//RF24 radio(8, 25);  //only CSN is NEEDED in RPI
+RF24 radio("/dev/spidev0.0",8000000 , 25);  //spi device, speed and CSN,only CSN is NEEDED in RPI
+
+//
+// Channel info
+//
+
+//const uint8_t num_channels = 128;
+const uint8_t num_channels = 120;
+uint8_t values[num_channels];
+
+//
+// Setup
+//
+
+void setup(void)
+{
+  //
+  // Print preamble
+  //
+
+  //Serial.begin(57600);
+  //printf_begin();
+  printf("\n\rRF24/examples/scanner/\n\r");
+
+  //
+  // Setup and configure rf radio
+  //
+
+  radio.begin();
+  radio.setAutoAck(false);
+
+  // Get into standby mode
+  radio.startListening();
+  radio.stopListening();
+
+  radio.printDetails();
+
+  // Print out header, high then low digit
+  int i = 0;
+  while ( i < num_channels )
+  {
+    printf("%x",i>>4);
+    ++i;
+  }
+  printf("\n\r");
+  i = 0;
+  while ( i < num_channels )
+  {
+    printf("%x",i&0xf);
+    ++i;
+  }
+  printf("\n\r");
+
+}
+
+//
+// Loop
+//
+/*
+const int num_reps = 100;
+
+void loop2(void)
+{
+  // Clear measurement values
+  memset(values,0,sizeof(values));
+
+  // Scan all channels num_reps times
+  int rep_counter = num_reps;
+  while (rep_counter--)
+  {
+    int i = num_channels;
+    while (i--)
+    {
+      // Select this channel
+      radio.setChannel(i);
+
+      // Listen for a little
+      radio.startListening();
+      delayMicroseconds(128);
+      radio.stopListening();
+
+      // Did we get a carrier?
+      if ( radio.testCarrier() )
+        ++values[i];
+    }
+  }
+
+  // Print out channel measurements, clamped to a single hex digit
+  int i = 0;
+  while ( i < num_channels )
+  {
+    printf("%x",min(0xf,values[i]&0xf));
+    ++i;
+  }
+  printf("\n\r");
+}
+*/
+//
+// Loop
+//
+
+const int num_reps = 100;
+
+int reset_array=0;
+
+void loop(void)
+{
+
+if ( reset_array == 1 ) {	
+  // Clear measurement values
+  memset(values,0,sizeof(values));
+  printf("\n\r");
+}
+
+  // Scan all channels num_reps times
+    int i = num_channels;
+    while (i--)
+    {
+      // Select this channel
+      radio.setChannel(i);
+
+      // Listen for a little
+      radio.startListening();
+      delayMicroseconds(128);
+      radio.stopListening();
+
+      // Did we get a carrier?
+      if ( radio.testCarrier() )
+        ++values[i];
+	if ( values[i] == 0xf ) {
+		reset_array = 2;
+	}
+    }
+
+  // Print out channel measurements, clamped to a single hex digit
+  i = 0;
+  while ( i < num_channels )
+  {
+    printf("%x",min(0xf,values[i]&0xf));
+    ++i;
+  }
+  printf("\n\r");
+}
+
+int main(int argc, char** argv)
+{
+        setup();
+        while(1)
+                loop();
+
+        return 0;
+}
+
+
+
+// vim:ai:cin:sts=2 sw=2 ft=cpp

digistump-sam/libraries/RF24/librf24-rpi/librf24/gpio.cpp

@@ -0,0 +1,68 @@
+/* 
+ * https://github.com/mrshu/GPIOlib
+ * Copyright (c) 2011, Copyright (c) 2011 mr.Shu
+ * All rights reserved. 
+ * 
+ * Modified on 24 June 2012, 11:06 AM
+ * File:   gpio.cpp
+ * Author: purinda (purinda@gmail.com)
+ * 
+ */
+
+#include "gpio.h"
+
+GPIO::GPIO() {
+}
+
+GPIO::~GPIO() {
+}
+
+void GPIO::open(int port, int DDR)
+{
+	FILE *f;
+	f = fopen("/sys/class/gpio/export", "w");
+	fprintf(f, "%d\n", port);
+	fclose(f);
+
+	char file[128];
+	sprintf(file, "/sys/class/gpio/gpio%d/direction", port);
+	f = fopen(file, "w");
+	if (DDR == 0)	fprintf(f, "in\n");
+	else		fprintf(f, "out\n");
+	fclose(f);
+}
+
+void GPIO::close(int port)
+{
+	FILE *f;
+	f = fopen("/sys/class/gpio/unexport", "w");
+	fprintf(f, "%d\n", port);
+	fclose(f);
+}
+
+int GPIO::read(int port)
+{
+	FILE *f;
+	
+	char file[128];
+	sprintf(file, "/sys/class/gpio/gpio%d/value", port);
+	f = fopen(file, "r");
+
+	int i;
+	fscanf(f, "%d", &i);
+	fclose(f);
+	return i;
+
+}
+void GPIO::write(int port, int value){
+	FILE *f;
+
+	char file[128];
+	sprintf(file, "/sys/class/gpio/gpio%d/value", port);
+	f = fopen(file, "w");
+	
+	if (value == 0)	fprintf(f, "0\n");
+	else		fprintf(f, "1\n");
+	
+	fclose(f);
+}

digistump-sam/libraries/RF24/librf24-rpi/librf24/gpio.h

@@ -0,0 +1,60 @@
+/* 
+ * https://github.com/mrshu/GPIOlib
+ * Copyright (c) 2011, Copyright (c) 2011 mr.Shu
+ * All rights reserved. 
+ * 
+ * Modified on 24 June 2012, 11:06 AM
+ * File:   gpio.h
+ * Author: purinda (purinda@gmail.com)
+ * 
+ */
+
+#ifndef H
+#define	H
+
+#include <cstdio>
+
+class GPIO {
+public:
+
+	/* Constants */
+	static const int DIRECTION_OUT = 1;
+	static const int DIRECTION_IN = 0;
+	
+	static const int OUTPUT_HIGH = 1;
+	static const int OUTPUT_LOW = 0;
+		
+	GPIO();
+	
+	/**
+	 * 
+     * @param port
+     * @param DDR
+     */
+	static void open(int port, int DDR);
+	/**
+	 * 
+     * @param port
+     */
+	static void close(int port);
+	/**
+	 * 
+     * @param port
+     * @param value
+     */
+	static int read(int port);
+	/**
+	* 
+	* @param port
+	* @param value
+	*/	
+	static void write(int port,int value);	
+	
+	virtual ~GPIO();
+	
+private:
+
+};
+
+#endif	/* H */
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/nRF24L01.h

@@ -0,0 +1,125 @@
+/*
+    Copyright (c) 2007 Stefan Engelke <mbox@stefanengelke.de>
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation 
+    files (the "Software"), to deal in the Software without 
+    restriction, including without limitation the rights to use, copy, 
+    modify, merge, publish, distribute, sublicense, and/or sell copies 
+    of the Software, and to permit persons to whom the Software is 
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be 
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+    DEALINGS IN THE SOFTWARE.
+*/
+
+/* Memory Map */
+#define CONFIG      0x00
+#define EN_AA       0x01
+#define EN_RXADDR   0x02
+#define SETUP_AW    0x03
+#define SETUP_RETR  0x04
+#define RF_CH       0x05
+#define RF_SETUP    0x06
+#define STATUS      0x07
+#define OBSERVE_TX  0x08
+#define CD          0x09
+#define RX_ADDR_P0  0x0A
+#define RX_ADDR_P1  0x0B
+#define RX_ADDR_P2  0x0C
+#define RX_ADDR_P3  0x0D
+#define RX_ADDR_P4  0x0E
+#define RX_ADDR_P5  0x0F
+#define TX_ADDR     0x10
+#define RX_PW_P0    0x11
+#define RX_PW_P1    0x12
+#define RX_PW_P2    0x13
+#define RX_PW_P3    0x14
+#define RX_PW_P4    0x15
+#define RX_PW_P5    0x16
+#define FIFO_STATUS 0x17
+#define DYNPD	    0x1C
+#define FEATURE	    0x1D
+
+/* Bit Mnemonics */
+#define MASK_RX_DR  6
+#define MASK_TX_DS  5
+#define MASK_MAX_RT 4
+#define EN_CRC      3
+#define CRCO        2
+#define PWR_UP      1
+#define PRIM_RX     0
+#define ENAA_P5     5
+#define ENAA_P4     4
+#define ENAA_P3     3
+#define ENAA_P2     2
+#define ENAA_P1     1
+#define ENAA_P0     0
+#define ERX_P5      5
+#define ERX_P4      4
+#define ERX_P3      3
+#define ERX_P2      2
+#define ERX_P1      1
+#define ERX_P0      0
+#define AW          0
+#define ARD         4
+#define ARC         0
+#define PLL_LOCK    4
+#define RF_DR       3
+#define RF_PWR      6
+#define RX_DR       6
+#define TX_DS       5
+#define MAX_RT      4
+#define RX_P_NO     1
+#define TX_FULL     0
+#define PLOS_CNT    4
+#define ARC_CNT     0
+#define TX_REUSE    6
+#define FIFO_FULL   5
+#define TX_EMPTY    4
+#define RX_FULL     1
+#define RX_EMPTY    0
+#define DPL_P5	    5
+#define DPL_P4	    4
+#define DPL_P3	    3
+#define DPL_P2	    2
+#define DPL_P1	    1
+#define DPL_P0	    0
+#define EN_DPL	    2
+#define EN_ACK_PAY  1
+#define EN_DYN_ACK  0
+
+/* Instruction Mnemonics */
+#define R_REGISTER    0x00
+#define W_REGISTER    0x20
+#define REGISTER_MASK 0x1F
+#define ACTIVATE      0x50
+#define R_RX_PL_WID   0x60
+#define R_RX_PAYLOAD  0x61
+#define W_TX_PAYLOAD  0xA0
+#define W_ACK_PAYLOAD 0xA8
+#define FLUSH_TX      0xE1
+#define FLUSH_RX      0xE2
+#define REUSE_TX_PL   0xE3
+#define NOP           0xFF
+
+/* Non-P omissions */
+#define LNA_HCURR   0
+
+/* P model memory Map */
+#define RPD         0x09
+
+/* P model bit Mnemonics */
+#define RF_DR_LOW   5
+#define RF_DR_HIGH  3
+#define RF_PWR_LOW  1
+#define RF_PWR_HIGH 2

digistump-sam/libraries/RF24/librf24-rpi/librf24/readme.txt

@@ -0,0 +1,31 @@
+this is library to use the nrf24l01 on the raspberry pi.
+
+it's based on the arduino lib from J. Coliz <maniacbug@ymail.com>.
+the library was berryfied by Purinda Gunasekara <purinda@gmail.com>.
+
+examples
+========
+you need to set the library path:
+cd examples
+export LD_LIBRARY_PATH=.
+./pingtest
+
+In my examples I used /dev/spidev0.0 and GPIO25
+I have a model 1 rpi so you should check if the pins are on the same spot
+nrf-vcc = rpi-3v3 (1)
+nrf-gnd = rpi-gnd (6)
+nrf-ce =  rpi-ce0 (24)
+nrf-csn = rpi-gpio25 (22)
+nrf-sck = rpi-sckl (23)
+nrf-mo = rpi-mosi (19)
+nrf-mi = rpi-miso (21)
+
+known issues
+============
+spidev0.0 or spidev0.1 doesn't seem to work. 
+
+contact
+=======
+Arco van Geest <arco@appeltaart.mine.nu>
+
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/spi.cpp

@@ -0,0 +1,132 @@
+/* 
+ * File:   spi.cpp
+ * Author: Purinda Gunasekara <purinda@gmail.com>
+ * 
+ * Created on 24 June 2012, 11:00 AM
+ * 
+ * Inspired from spidev test in linux kernel documentation
+ * www.kernel.org/doc/Documentation/spi/spidev_test.c 
+ */
+
+#include "spi.h"
+
+SPI::SPI() {
+	
+//	this->device = "/dev/spidev0.0";;
+	this->bits = 8;
+//	this->speed = 24000000; // 24Mhz - proly doesnt work
+//	this->speed = 16000000; // 16Mhz 
+//	this->speed = 8000000; // 8Mhz 
+	this->speed = 2000000; // 2Mhz 
+	this->mode = 0;
+
+//	this->init();
+}
+
+void SPI::setbits( uint8_t bits )
+{
+ this->bits = bits;
+}
+
+void SPI::setspeed( uint32_t speed )
+{
+ this->speed = speed;
+}
+
+void SPI::setdevice( string devicefile ) 
+{
+	this->device = devicefile;
+}
+
+void SPI::init()
+{
+	int ret;
+	this->fd = open(this->device.c_str(), O_RDWR);
+	if (this->fd < 0)
+	{
+		perror("can't open device");
+		abort();
+	}
+
+	/*
+	 * spi mode
+	 */
+	ret = ioctl(this->fd, SPI_IOC_WR_MODE, &this->mode);
+	if (ret == -1)
+	{
+		perror("can't set spi mode");
+		abort();		
+	}
+
+	ret = ioctl(this->fd, SPI_IOC_RD_MODE, &this->mode);
+	if (ret == -1)
+	{
+		perror("can't set spi mode");
+		abort();				
+	}
+	
+	/*
+	 * bits per word
+	 */
+	ret = ioctl(this->fd, SPI_IOC_WR_BITS_PER_WORD, &this->bits);
+	if (ret == -1)
+	{
+		perror("can't set bits per word");
+		abort();				
+	}
+
+	ret = ioctl(this->fd, SPI_IOC_RD_BITS_PER_WORD, &this->bits);
+	if (ret == -1)
+	{
+		perror("can't set bits per word");
+		abort();						
+	}
+	/*
+	 * max speed hz
+	 */
+	ret = ioctl(this->fd, SPI_IOC_WR_MAX_SPEED_HZ, &this->speed);
+	if (ret == -1)
+	{
+		perror("can't set max speed hz");
+		abort();						
+	}
+
+	ret = ioctl(this->fd, SPI_IOC_RD_MAX_SPEED_HZ, &this->speed);
+	if (ret == -1)
+	{
+		perror("can't set max speed hz");
+		abort();						
+	}
+}
+
+uint8_t SPI::transfer(uint8_t tx_)
+{
+	int ret;
+	// One byte is transfered at once
+	uint8_t tx[] = {0};
+	tx[0] = tx_;
+
+	uint8_t rx[ARRAY_SIZE(tx)] = {0};
+	struct spi_ioc_transfer tr;
+	tr.tx_buf = (unsigned long)tx;
+	tr.rx_buf = (unsigned long)rx;
+	tr.len = ARRAY_SIZE(tx);
+	tr.delay_usecs = 0;
+//	tr.cs_change = 1;
+	tr.speed_hz = this->speed;
+	tr.bits_per_word = this->bits;
+
+	ret = ioctl(this->fd, SPI_IOC_MESSAGE(1), &tr);
+	if (ret < 1)
+	{
+		perror("can't send spi message");
+		abort();		
+	}
+
+	return rx[0];
+}
+
+SPI::~SPI() {
+	close(this->fd);
+}
+

digistump-sam/libraries/RF24/librf24-rpi/librf24/spi.h

@@ -0,0 +1,53 @@
+/* 
+ * File:   spi.h
+ * Author: Purinda Gunasekara <purinda@gmail.com>
+ * 
+ * Created on 24 June 2012, 11:00 AM
+ */
+
+#ifndef SPI_H
+#define	SPI_H
+
+#include <string>
+#include <stdint.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <inttypes.h>
+#include <linux/types.h>
+#include <linux/spi/spidev.h>
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+using namespace std;
+
+class SPI {
+public:
+	
+	SPI();
+	uint8_t transfer(uint8_t tx_);
+	virtual ~SPI();
+	void init();	
+	void setdevice( string devicefile );
+	void setbits( uint8_t bits );
+	void setspeed( uint32_t speed );
+
+private:
+
+	// Default SPI device
+	string device;
+	// SPI Mode set 
+	uint8_t mode;
+	// word size
+	uint8_t bits;
+	// Set SPI speed
+	uint32_t speed;
+	int fd;
+
+};
+
+#endif	/* SPI_H */
+

digistump-sam/libraries/RF24/librf24-rpi/readme.md

@@ -0,0 +1,42 @@
+Raspberry Pi RF24 libraries
+===========================
+
+This is the collection of libraries for RF24 / NRF24L01 wireless modules on the raspberry pi.
+
+There are two folders with two different libraries :-
+
+- librf24 	 This library/driver are ported from Arduino to beaglebone then to RPi
+- librf24-bcm 	 This library/driver are further ported to use Broadcom bcm2835 using hardware SPI
+
+Setup
+=====
+1. Change to the selected folder
+2. Execute "make" and "sudo make install" to install the shared libraries
+3. Change to examples folder, change to the correct connected pins and execte "make"
+
+
+
+Known issues
+============
+- the current bcm2835 drivers still have some minor bugs
+
+Links 
+=====
+- Forum links : http://www.raspberrypi.org/phpBB3/viewtopic.php?f=45&t=17061
+- C library for Broadcom BCM 2835 http://www.open.com.au/mikem/bcm2835/index.html
+- Maniacbug RF24 http://maniacbug.github.com/RF24/index.html
+- RF24 Class Reference http://maniacbug.github.com/RF24/classRF24.html
+
+
+Contact
+=======
+Stanley Seow ( stanleyseow@gmail.com )
+https://github.com/stanleyseow/RF24
+
+RF24 for RPi using gpio :-
+Arco van Geest <arco@appeltaart.mine.nu> 
+https://github.com/gnulnulf/RF24
+
+RF24 for RPi using bcm2835 :-
+Charles-Henri Hallard http://hallard.me/ 
+https://github.com/hallard/RF24

digistump-sam/libraries/RF24/librf24-rpi/readme.txt

@@ -0,0 +1,31 @@
+this is library to use the nrf24l01 on the raspberry pi.
+
+it's based on the arduino lib from J. Coliz <maniacbug@ymail.com>.
+the library was berryfied by Purinda Gunasekara <purinda@gmail.com>.
+
+examples
+========
+you need to set the library path:
+cd examples
+export LD_LIBRARY_PATH=.
+./pingtest
+
+In my examples I used /dev/spidev0.0 and GPIO25
+I have a model 1 rpi so you should check if the pins are on the same spot
+nrf-vcc = rpi-3v3 (1)
+nrf-gnd = rpi-gnd (6)
+nrf-ce =  rpi-ce0 (24)
+nrf-csn = rpi-gpio25 (22)
+nrf-sck = rpi-sckl (23)
+nrf-mo = rpi-mosi (19)
+nrf-mi = rpi-miso (21)
+
+known issues
+============
+spidev0.0 or spidev0.1 doesn't seem to work. 
+
+contact
+=======
+Arco van Geest <arco@appeltaart.mine.nu>
+
+