Arduino is a microcontroller and development environment that can be used, just like Raspberry Pi, to read information from its sensors and control other devices.
Programming on the Arduino is extremely simple, which has led to its widespread use in interactive environments. As with the Raspberry Pi, it’s a great (and low cost) starting point for experimenting with the world of embedded wearables and the Internet of Things.
This blog walks you through the steps to connect an Arduino to the PubNub Data Stream Network. This enables you to connect with a high volume of other devices at a global scale and start sending and receiving data between a wide variety of devices, including other Arduino and Raspberry Pi devices.
PubNub acts as your communication layer for signaling and data transfer between embedded devices. Some of the advantages of using the PubNub Data Stream Network over a custom, open source solution is reliability and speed. PubNub takes care of the backend infrastructure that you’d have to set up otherwise to create a signaling network between Arduino and other connected devices. You can find the Arduino PubNub extensions here. For additional resources, check out the PubNub Arduino documentation page. 
Basics of Connecting the Arduino to The PubNub Data Stream Network
Really, all it takes is two steps to get your Arduino up and running. Follow these steps to get connected:
STEP 1: Connect the Arduino to a monitor, keyboard, mouse and ethernet cable. You’ll also have to sign up for a PubNub account to get your unique keys. PubNub is entirely free in the sandbox tier, which gives you more than enough bandwidth to test and play with your Arduino.
STEP 2: Open a new window and paste the following code.
#include
#include
#include "string.h"
#include "iotconnector.h"
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
char pubkey[] = "demo";char subkey[] = "demo";char channel[] = "iotchannel";char uuid[] = "Arduino";
iotbridge arduino;
void initialize(){
Serial.begin(9600);
Serial.println("Serial set up");
while (!Ethernet.begin(mac)) {
Serial.println("Ethernet setup error");
delay(1000);
}
Serial.println("Ethernet set up");
}
void do_something(String value){
Serial.println("in the callback");
Serial.println(value);
}
void setup()
{
initialize();
arduino.init( pubkey, subkey, uuid);
}
void loop()
{
String returnmessage;
Ethernet.maintain();
//Publish
arduino.send(channel,""Hey There"");
//Subscribe
returnmessage = arduino.connect(channel);
//callback function of sorts, to work with the received message
do_something(returnmessage);
Serial.println();
}
The above code lets you set the following :
- publish key using “pubkey”
- subscribe key using “subkey”
- UUID using “uuid”
- channel you wish to subscribe and publish to using “channel”
For all of you who are familiar with Arduino, you will notice that this is in fact only a few additional lines of code in loop(). The remaining code sets up the Ethernet connection to the Arduino. The keys lines of code are just three lines:
- arduino.init() that lets you initialize variables
- arduino.send() that lets you send a message over the specified channel
- arduino.connect() that lets you subscribe to a channel to receive messages
We create an instance of the iotbridge called “arduino” and we can use the SEND and CONNECT methods belonging to that class. SEND: This invokes the publish() API to send any message over a desired channel.
bool iotbridge::send(const char *channel, const char *message){
EthernetClient *client;
client = PubNub.publish(channel,message);
return client;
}
CONNECT: This invokes the subscribe() API to listen for messages from other embedded devices connected to the same channel. NOTE: The call back function receive is invoked when subscribe runs. Connect() will block on subscribe, waiting for a message to be sent to the device. You can write your own simple task scheduler and bounce between tasks according to their timing requirements.
String iotbridge::connect(const char *channel){
PubSubClient *pclient = PubNub.subscribe(channel);
You can customize the channels you publish/subscribe to, the UUID you assume and also the messages you send by just changing the above fields. And that’s it! You can now talk Arduino to any other device or application subscribing/publishing to the same channel.
