The SwiftLink™
RD-11 Radio Network Interface

 
Microprocessor + Network Operating System + Radio Transceiver
  A single package creating very easy to use wireless connections between multiple Arduino systems.
 
 
 
 
INNOVATION: THE SWIFTLINK™ OPERATING SYSTEM AND "ENTANGLED VARIABLES"
 
The SwiftLink™ Radio Network Interface has an on-board processor and radio transciever, and an operating system
which handles ALL of the radio and network programming for you and frees you to just use your data.
 
The SwiftLink OS, has no API whatsoever, but instead creates a concept we call "Entangled Variables".
 
An "entangled" variable is a variable, declared in multiple programs running on multiple systems in multiple locations,
which is maintained by the SwiftLink™ OS to have the same value at all times in all copies!
 
It is similar to a "global", except that it is global throughout an entire network.
 
Store a value into an entangled variable at one location and pick up that new value at any other locations!
 

     Program #1 running in Arduino #1:

  #include "SwiftLink.h"
 
  // store random data and sensor values
 
  entangled_int(alpha);
  entangled_int(beta);

 
  loop() {
   alpha = random(0,9999);
   beta = analogRead(0);
   delay (1000);
  }
UP TO
<------500------>
FEET

     Program #2 running in Arduino #2:

  #include "SwiftLink.h"

  // print the data as received

  entangled_int(alpha);
  entangled_int(beta);


  loop() {
   Serial.println(alpha);
   Serial.println(beta);
   delay (1000);
  }
 
NETWORK I/O DEVICES CAN BE COMPLEX AND DIFFICULT TO PROGRAM!
 
The RD-11 SwiftLink establishes an ad-hoc mesh network among any number of SwiftLink devices in the area.
 
Many types of radio devices, including WiFi, Bluetooth, Zigbee, and OOK radios, can be very difficult to use. They have numerous parameters that have to be determined or setup. Master/Slave modes; node IDs; IP addresses; Firewall setups. Adding a new node on the fly can be difficult. A lot of programming is needed to coordinate and send data from system to system. Arduino projects using these shields often spend more time getting the radios setup and working then the entire rest of the project!
 
Establishing and maintaining an ad-hoc mesh network and passing reliable, encrypted packets takes a bunch of code!
 
We know. We've done it!
 
So now you don't have to!

 

 
ENTANGLED VARIABLES ARE SIMPLE AND EASY TO PROGRAM!
 
We propose a new concept: "entangled variables" as the interface between a radio device like ours
and a user program like yours.
 
Through C++ class definitions and operator overloads, the OS creates a software layer on top of its network, consisting merely of "entangled" variables. The entire SwiftLink™ Radio Network Interface software interface is demonstrated with just one line of code:
 
entangled_int (alpha);
 
  The variable alpha may be used like any other integer variable in your program, just as if the declaration had been
"int alpha" instead of "entangled_int(alpha)"
 
But all C++ references to an entangled variable get intercepted by the SwiftLink OS, which then automatically ensures
that the variable's value is always up-to-date across the network. The majority of the OS runs in the SwiftLink
processor itself, which caches and optimally transmits the data between systems as needed.
 
The SwiftLink OS will handle any number of entangled variables (up to memory limits). In addition to entangled_int, you can also declare:
 
entangled_byte, entangled_bool, entangled_float, entangled_longInt, and entangled_charString.
 
With this form of "non-API", you can "forget about" the network. It disappears from view. Note that the amount of radio I/O (bytes transmitted) is not necessarily any different whether you send data in the traditional way, or let the SwiftLink OS send the data for you. Every attempt is made to optimize the I/O. But do you really care? If you have a large volume of high-rate data, this device is not for you. If you have a medium or low volume, this is exactly the device for you!
 
The SwiftLink OS creates a radio network and puts it "inside the box" where it belongs,
so that you can work "outside the box"!
 
 
The SwiftLink™ costs about the same as many WiFi, Bluetooth, Zigbee or other Arduino boards.
But why buy one of them, when the SwiftLink gives the ability you need:
communication between multiple Arduino systems,
and with ZERO programming effort.
 
 
NO SETUP OF ANY KIND. JUST POWER IT ON!
 
When turned on, a SwiftLink will automatically detect all other SwiftLink systems in the area
and self-configure itself into the network. There is no setup, no parameters, no network addresses, no modes.
No maintenence. No configuration. No node numbers. No nothing! Everything about the network is "inside the box".
 
They simply connect and work. Your entangled variabes will be entangled!

They will recover after power fail. They will tolerate interference.
Their transmissions are secure (encrypted) and reliable (packetized with error detection codes).
Depending on antenna placement, power supply and wall materials, they can be as much as 500 feet apart.
 
All of the radio and network code, the SwiftLink OS©, is run in the SwiftLink™ device itself. Only the class definitions
and a small amount of interface code is added to your own Arduino code. You merely "#include SwiftLink.h",
available free from our website and you are ready to declare and use entangled variables.
 
For further reading and many examples, see: The Manual!
 
 
CLICK HERE TO BUY NOW!
 
 
Watch a video demonstration!
 



HERE IS THE OLD WAY, USING THE CONCEPT OF "NETWORK CONNECTION"
TO GET THE NUMBER "538" FROM SYSTEM A TO SYSTEM B:
WITH A WIFI, BLUETOOTH, ZIGBEE, ETC TYPE DEVICE
(This is a highly simplified version of what you would have to do -- the reality would be MANY more lines of code!)
// this code on system A:

alpha = 538;

establishLink(nodeNumberOfB);
buf[5]; // create an array of bytes     
buf[0] = headerByte;
buf[1] = 2; // lengthOfData
buf[2] = lowByte(alpha);
buf[3] = highByte(alpha);
buf[4] = computeChecksum(buf,0,3);
sendDataOnLink(buf);

// this code on System B:



establishLink(nodeNumberOfA);
readDataOnLink(buf);
assert ( buf[0] == expectedHeaderByte );
int len = buf[1]; assert (len == 2);
alpha = buf[3]<<8 | buf[2];
assert ( buf[4] == computeChecksum(buf,0,3);

Serial.println(alpha);
AND THIS IS HOW WE DO IT ON A SWIFTLINK,
USING THE CONCEPT OF "ENTANGLED VARIABLES" INSTEAD:
(This is NOT simplified pseudo-code. This is the actual code!)

entangled_int (X);

X = 538;


entangled_int (X);

Serial.print(X);

For further reading and many more examples, see: The Manual!

You'll need two to get started!

Click here and get yours now!!

Oh, and there is
One more thing...

The SwiftLink™ has an extra connector along the bottom with a number of digital and analog I/O pins.
Each of these pins may be accessed thru a set of predefined entangled_int variables, namely:

RDxxxx_D0, RDxxxx_D1, RDxxxx_D2, ..., RDxxxx_D5
RDxxxx_A0, RDxxxx_A1, RDxxxx_A2, ..., RDxxxx_A5

where "xxxx" represents the unique 4 digit serial number found on the back of the RD-11 unit.
These pins may then be accessed from anywhere in the local network. Thus, any RD-11 gives you 12 remote entangled I/O pins.

The Stand-Alone SwiftLink Remote Sensor

If you provide power only (+5V and Ground) to an RD-11, it will begin operation immediately. Although it has no host Arduino to command it, the above pins variables will be monitored and updated at regular (specifiable) intervals.

Thus, to create a remote sensor or actuator node, one can merely connect any 5V analog or digital sensor or actuator to an RD-11, give it power, and with no Arduino (at that location), access it from any other Arduino/SwiftLink system in the area!

And if an RD-11 that is not connected to an Arduino host detects another un-hosted RD-11 in the area, the two will pair up and cross-connect their D0 and D1 pins. Whatever input is presented to one's D0 will be output at the other's D1 and vice versa! Thus, for example, you can put a push-button on one's D0 pin, a buzzer on the other's D1 pin, and WITH NO PROGRAMMING WHATSOEVER, the two systems, right out of the box, will pair up on power-up and immediately connect the button to the buzzer!

You can see a video demonstration of this here!

See the manual for much more info!



© 2011 Swift Enterprises