FAQ

General

What is Radio For X:duino?
[meta_value=00100]

RFXduino is a means for giving your Arduino and Arduino-like embedded projects full TCP/IP connectivity to the Internet — but easily and affordably. The key to keeping the cost down is that the wireless connection is via inexpensive nRF24L01+ modules. It provides an alternative to more expensive/more difficult to program Ethernet shields, WiFi shields and Yun.

Up to 255 embedded projects can connect to your LAN, and thereby the Internet (if desired), by connecting through a single central TCP/IP gateway device, the RFX hub. The RFX hub is an embedded linux-based device (Raspberry Pi+RFX daughterboard) that provides a separate TCP/IP serial connection to the network for each embedded project.

And what exactly is an “X:duino”?
[meta_value=00200]

Disambiguation: I use the term X:duino to mean “Arduino or Arduino-like device” to save me from typing (and you from having to read) “Arduino or Arduino-like device” repeatedly. Not to be confused with any actual product that uses the name “Xduino” or even “X-duino” (note I use a colon).

What Arduino/X:duino boards have been tested to work with RFX so far?
[meta_value=00300]

RFXduino has been designed to work with both the genuine Arduino devices (e.g., Uno, Mega, Nano, Leo, Due), as well as many of the Arduino-derived board designs, both AVR based and ARM based.

For example, as well as the genuine Arduino boards, RFX has been currently tested to work with the PJRC Teensy 3.0, the LeafLabs Maple r5 board, the IteadStudio Iboard (which handily has a built-in nRF24l01+ module header), the “Meduino” 328 variant, as well as standard “knock-off” Arduino clones (Uno, Nano and Mega variants have been tested so far).

There is also the minimalist RFX 328 Uno-class development board, specially designed as a flexible, low-cost deployment solution (available as a kit in the EmbeddedCoolness .com store.)

The list of tested compatible boards tested so far is summarized below:

AVR ARM
Arduino Uno Arduino Due (Cortex-M3)
Arduino Nano (328) Leaflabs Maple r5 (Cortex-M3)
Arduino Mega (1280/2560) PJRC Teensy 3.0/3.1 (Cortex-M4)
Arduino Leonardo PJRC Teensy-LC (Cortex-M0+)
IteadStudio IBoard
Various other 328p derivatives (e.g. “Meduino”, Arduino clones etc.)
And of course, all the Embedded Coolness boards:
RFX 328/nRF24L01+/proto dev/deployment board
RFX 1284p dev/dep board “Skinny Bob”, etc.

The list of tested compatible boards is expected to grow steadily. RFX has been designed for portability from the outset, so most of the effort in adding a new AVR or Arm-based X:duino variant to the “tested” list will be in actually getting a board to work with. If you have a particular “X:duino” board in mind, drop us a line via the “contact” form, and we can advise.

But there are already libraries available for interfacing an nRF24L01+ to an Arduino (or similar) device. What is different about RFX?
[meta_value=00400]

RFXduino supports stream connections, rather than just packet connections. The protocol design and implementation has resulted in a wireless analog of Serial.print() and Serial.read(). With RFXduino, you read and write bidrectional buffered streams to the Internet (TCP/IP).

This means your Arduino/X:duino can serve webpages, send emails, POST data to servers, connect via Telnet, and so on — all that good Internet stuff that previously you would need an Ethernet or Wifi Shield for!

Other nRF24L01+ libs implement short packet based messaging, sometimes between the embedded devices, typically aimed at achieving a “mesh” sensor network.

RFXduino is not peer-to-peer, and in particular, doesn’t implement a “mesh” networking model. All client nodes (the Arduinos) communicate directly with only the server node (the gateway) — a star networking model. Any communication between client nodes is therefore facilitated and coordinated via the gateway server, which acts as a router.

That’s what’s different about RFXduino!

If I only want to connect one X:duino project to the Internet, wouldn’t it be cheaper to (say) buy a wifi shield rather than a RFX gateway device?
[meta_value=00500]

Possibly — but if you already own an under-employed Raspberry Pi that is looking for gainful employment, then adding the “BYO kit” RFXduino gateway hardware to it may actually be cheaper than even buying one Wifi shield, depending on the brand (buying one genuine Arduino brand Wifi shield would definitely be more expensive).

And if you want to connect two projects to the Internet, the price of the RFXduino gateway hub (even including the Raspberry Pi) may already be less expensive than cost deploying two Wifi shields.

And once you get to three or more embedded projects, you are well ahead. The dollars you save for each additional project you deploy is simply liberating. It just opens up the possibilities as what projects it’s economically feasible to add wireless network connectivity to. Suddenly, it’s all of them!

Therefore, RFXduino is squarely aimed at those embedded project enthusiasts who simply can’t stop at one. Or just can’t stop, period. The “serial offenders”, you might say (pun intended, no apology.)


Getting started

What hardware/software do I need (at a minimum) to get up and running with RFX?

Hardware: You need a RFXduino gateway device, which is a dedicated Raspberry Pi motherboard + RFX daughterboard (with nRF24L01+ module) + SD Card (with RFXduino gateway software pre-installed.) You also need one or more client devices to connect with. A client device is just an Arduino/X:duino with an appropriately connected (high or low power) nRF24L01+ module.

Software: You need two libraries, Rfx_printfns_xx and Rfx_xx (“xx” will reflect the current release number). Once these are installed into the mysketches/libraries directory in your Arduino/X:duino development environment, an RFX-enabled sketch can be developed by including the directives #include “Rfx_config.h” and #include <Rfx_xx.h> . (Each sketch will have its own private Rfx_config.h configuration file, located in the same directory as the main sketch file, which specify the RFX configuration options selected for that particular sketch.)

You should also have a suitable terminal program (such as PuTTY) installed to allow access to the linux command line interface on the RFXduino gateway when required.

I already own a Raspberry Pi. Can I use that for the RFX gateway device?

Sure, provided it is a Model B with the Ethernet port. The only additional hardware you will have to buy to provision a standard RPi Model B is an RFXduino gateway daughterboard, which comes with an SD Card that has the RFXduino gateway software preinstalled and a version of “Raspbian” linux configured for RFX.

When you order the RFXduino gateway, the RFX perspex case, the high-power nRF24 radio module, and the Raspberry Pi itself are optional add-ons.

What are my options for connecting a nRF24L01+ module to my project so it can connect to RFX?

An nRF24L01+ module can be interfaced using an EmbeddedCoolness RFX nRF24L01+ shield, or by using a custom interfacing arrangement – it doesn’t matter.

Some X:duino boards (such as the IteadStudio IBoard, or the RFX 328/nRF24L01+/proto board) already come equipped with a nRF24L01+ module connection header, which can be very convenient as well as cost-effective, as interfacing becomes as simple as plugging in the nRF24L01+ module.

Where can I find user documentation for the RFX libraries?

We will be providing both basic and more advanced documentation on this site that we will be aiming to steadily expand and improve over time, based on feedback from users. So if you’ve got a question that isn’t answered adequately in the docs, or the docs could be clearer on some point, please drop us a line.

Looking at the demo sketches (under “Example programs” in the “Docs” section), which range from “hello world” level examples to some of the more advanced features of RFX, would be a natural starting point.

Why have the RFX functions been split over two separate libraries?

Actually RFX is composed of five separate libraries, but they are packaged up into two “compound” libraries, Rfx_xx and Rfx_printfns_xx.

Two top level libraries were chosen rather than one large one, because the subset of functions contained in Rfx_printfns_xx library are also potentially useful in a standalone application that only needed the advanced printing/flash string handling functions of RFX, but not full RFX wireless connectivity.

Do I need to know Linux?

The RFX gateway configuration is set-up as a “headless” linux device, meaning that access to the command line is assumed to be via network login (ssh/telnet), rather than by an attached keyboard, mouse and monitor.

You will need some basic command line skills to configure things to your preferences and requirements, but you certainly don’t need to know much more than “cd” to navigate to the directory you need to work in and “nano” (or whatever text editor you prefer to use) to modify configuration files.

If you know _any_ Linux (or any variant of UNIX, for that matter), you probably know more than enough to get things up and running — but the more you know, the better of course! (particularly when it comes to extending the functionality of the RFX gateway to new applications, as it’s all designed to be hackable.)

Here are a list of commands/utilities that you would already want to be familiar with:

ssh or telnet
ftp
cd, mv, rm, ls
chmod
chown
sudo
shutdown
su
nano (or equivalent text editor)
simple bash scripting


Shipping, sales tax etc.

How long will my order take to arrive?

That will depend on your destination address. The default shipping is ordinary airmail, so it may take a few weeks to arrive. Please contact us via the contact form if you need a more precise estimate.

If you require a faster shipping option, please contact us via the contact form, and we will advise on the options to your location.

Do I pay any sales tax?

No. Sales tax/VAT/GST is not applicable to any sales at the moment. (Australian customers — that’s right, GST is not charged at this stage.)

What countries do you ship to?

We are currently set-up to ship to the US, Canada, UK, Australia and New Zealand, and (some) European countries. We expect to add more countries to this list in the future, however, so stay tuned.


Orders/backorders/returns/refunds

What is your policy on backorders?

If a product has been ordered but we find we cannot ship it immediately, we will advise the customer and they will have the option of a total or partial refund for that order.

As a matter of policy, we try to avoid backorders, as restocking times can be quite lengthy and unpredictable for certain items. So instead of a backorder, we can arrange instead to notify the customer when stock becomes available again, if they so request.

What is your policy on cancelations?

Orders can be cancelled at any time up until shipment. After shipment, it becomes a return/refund situation.

What is your policy on returns/refunds?

Returns and refunds will be dealt with on case-by-case basis. If it is our error (wrong item, item not sent etc.), we will obviously make good at no cost to you. If you wish to return something, the condition of the item and suitability for restocking may have to be assessed prior to making a full or partial refund. Shipping costs may also be factored into refund calculations in some situations.

In general, we don’t want disappointed or unhappy customers, so we will try to be as fair and generous as possible, and will work with you to arrive at a mutually acceptable outcome. Please read the shipping FAQ to be aware of the potentially extended delivery times for an order.


Licensing

What is the software license?

The RFX library software is licensed as personal use, non-redistributable open source.

In a nutshell, you can make copies of the original and modified copies of the RFX library source code for your personal use, but you can’t distribute the source, in either original or modified form, to third parties.

You can distribute any compiled/linked object/executable code without restriction, however.

Finally, there are the standard “DBAA” conditions: Use responsibly. Deploy any systems you build with due care and respect for the inherent limitations of the software and hardware. If you do anything that results in causing anyone or anything harm, all liability rests with you, not us.

That’s pretty much the gist of it. To see how this compiles into legalese (which is perhaps only rivaled for verbosity by COBOL), read the full EULA.