RF24Gateway - Creating Hybrid IoT Networks using TCP/IP and RF24Network
RF24Gateway User Interface Example
RF24Gateway is a new complimentary library to RF24Ethernet, designed for RPi and Linux based devices with SPI and GPIO capabilities (BBB, Intel Edison, Galileo, etc).
The RF24Gateway library acts as a network/internet gateway, and allows Arduino/AVR based sensor nodes to interact with each other, the environment, and the world using TCP/IP and/or lower level RF24Network messages.
In short, it allows hybrid IoT networks to be created using Arduino and nrf24l01 modules. Some nodes are capable of internet or local network communication using standard protocols (TCP/IP) and/or RF24Network messages, while other nodes can communicate only at the network level, using only the lower layer RF24Network messaging.
Once RF24Gateway is configured, nodes can be controlled completely using standardized tools and protocols. Additional client examples have been added to demonstrate how to control and/or receive
information from sensor nodes using standard tools and scripting methods
via Bash, NodeJS and Python scripts. Any method of establishing a TCP connection can be used, with the examples generally using HTTP to some degree as well.
Libraries and code that utilizes RF24Network can utilize RF24Gateway in
much the same way, since external data types (TCP/IP) are handled out of
sight from the user. RF24Network is used exactly the same way, except
that the gateway.update() function is called instead of network.update()
or mesh.update(). The included examples demonstrate usage.
Note: RF24Gateway defaults to using a TUN interface with RF24Mesh enabled. RF24Ethernet examples have been updated to accommodate this. Current Status:
April 2015: Near completion. Integrated fully with RF24Ethernet. Graphical (NCurses) interface example finalized.
ENC28J60 Network Modules, Arduino and the Internet of Things (IoT):
An experiment, overview and analysis of TCP/IP networking with Arduino Ethernet
The module in question was sent to me by the friendly people at ICStation.com , in exchange for a review of the module itself.
Video Review:
ENC28J60 Mini Network Module:
3.3V operation
Create a mini Arduino Web Server or Client
Plugs into your home router or modem just like a computer
The uIP TCP/IP stack is software driven, while the ENC28J60 module handles the data mainly at the network (Ethernet) level. One main difference between UIPEthernet and the official Arduino Ethernet library is the need to keep the TCP/IP stack updated via software with the ENC28J60.
Hardware:
The ENC28J60 was very easy to wire up, using the default SPI pins shown at http://arduino.cc/en/Reference/SPI along with the VCC and Ground pins. The
device seems to work ok connected to the 3.3v output of the Arduino,
but it seems best to use an external power supply or battery.
Software:
Two main libraries appear to be available: Ethercard and the UIPEthernet libraries. This post will focus on usage via UIPEthernet, since it shares a common API with the official Arduino Ethernet library.
In attempting to utilize the modules and UIPEthernet for creating a simple webserver, I ran into a number of issues with data being sent or received incorrectly. Over a number of days, and benefiting from the information gained in building the RF24Ethernet library, I have been working to improve UIPEthernet, and also created some examples to demonstrate the issues and current usage.
(A pull request has been made regarding these suggested changes to the main library)
Overview of Library Changes (At the time of this post): Changes:
Introduce client.waitAvailable(); function - Ensures the IP stack is processing incoming data while waiting for incoming data for a maximum defined duration in milliseconds: client.waitAvailable(3000);
Introduce Ethernet.update(); function - Allows user applications to ensure the IP stack is processing data while delaying or performing other tasks: Ethernet.update();
Perform additional processing of data while calling client.available();
Per testing, reduce max segment size (MSS) and the receive window to 511 bytes from 512 due to unidentified issue.
Reduce number of packets per socket to prevent data loss
Re-open the TCP window at timed intervals when data has not been sent or received on an open connection to prevent stalling during large downloads
Fix for outgoing data corruption
Force application to wait while writing data
Better TCP window handling
Other minor changes, add examples
Changes - Technical Summary:
The first changes introduced added some new functionality, geared towards a software driven IP stack. With the addition of additional processing and the Ethernet.update() function, the IP stack is more responsive to ICMP requests etc.
The new examples included with my branch of the library clearly demonstrate some of the issues I encountered when attempting to create a simple web client and/or web server. The first issue I noticed involved the device crashing or stalling, and then failing to reconnect or respond to pings. Testing indicated that the hardware itself was still responding and receving packets, so the issue seemed to be software based. These issues mostly seem to be addressed in the fix_errata12 branch, but testing via large dowloads from a web server indicated there were still some remaining issues, mostly surrounding data corruption and flow control.
Most of the remaining changes attempt to address issues with corrupted or out of sequence data, and to manage the flow of data better. In some situations, for example, web servers will send TCP payloads equal in size to 1/2 of the TCP Max Segment Size (MSS) which causes problems with flow control. The IP stack will now only close the TCP window if data is being received fast enought to do so, which appears to reduce issues with these transfers. The main issues come when a sending device sends only 1/2 MSS, and the recipient closes the window. The library will now count individual bytes in memory vs packets with data in them, and only close the TCP window if the assigned data buffers are completely full.
Testing has been very successful, with the device demonstrating full functionality for extended periods of time, downloading 70+MB of data without any errors detected in the data or hardware. The new web server examples and HttpClientTest.ino example seem to be good displays of the current capabilities and error free operation, and can be used to demonstrate the issues, when used with the original library code, or when changes are reverted.
Summary:
The mini ENC28J60 modules are an inexpensive and effective way to add internet connectivity to any Arduino project, and their size make them very suitable for use with Arduino.
I found the hardware itself to be very reliable and easy to use, although there seemed to be a few minor issues with the related Arduino library (UIPEthernet) that was tested.
As noted, I have submitted some workarounds/fixes for review and possible integration into the main library at the time of this post, so users are encouraged to use the library linked above.
ICStation.com:
A big thank you to www.ICStation.com for sending me this product, as well as being very patient.
It has been a number of months since I actually received it, but their small contribution has lead to the creation of the RF24Ethernet TCP/IP Radio Network library, and some potential improvements to the UIPEthernet library. A wealth of Arduino and Raspberry Pi related products, gizmos and devices are available on their website, and their staff seem very friendly.
