Internet of Customers – Bluetooth Presence Detection & Salesforce

Internet of Customers – Bluetooth Presence Detection & Salesforce

In Internet of Customers – “Jarvis” Style Personal Agenda with Arduino, Bluetooth and Salesforce we used an Arduino to scan for Bluetooth MAC addresses, identify a guest and read aloud the tasks for that user. In this post, we will cover the approach & code used within the proof, as well as supply it for download.

Jarvis-YouTube-IOC-IOT-Background-Footer

Overview & Bluetooth Module Challenges
The toughest part of this proof was getting the Bluetooth detection working, as my first efforts were potentially complicated with a bad Bluetooth module. I ended up using a Sparkfun Bluetooth Mate Silver with terrific results. It did require soldering, but it ended up being a pretty straightforward process.

Once the Bluetooth was working, I was able to use some excellent Bluetooth detection sample code from Jan Stevens to listen for Bluetooth IDs. Merging this with some code from our Internet of Customers – Heroku, Arduino and Salesforce.com for Customer Service example, we are easily able to send any matches to a Node.js application to evaluate against Salesforce for guest identification.

Communication Between Systems
The screens below show console output from the Node.js application, showing any data it has received from the Arduino, as well as some response data coming back from Salesforce1 APIs. The Node.js application then uses Web Sockets to communicate to the client dashboard with our greeting UI.

bt-arduno-process

Salesforce Field Setup
This is the easiest part of the proof and adding custom fields in explained here. Our Node.js will need to query fields to see if the ID sent by the Arduino device will match a user’s Bluetooth ID in Salesforce. If so, retrieve the user photo, as well as a speaking voice preference.
Jarvis-Image-2b

Greeting Dashboard
Using Web Sockets, the dashboard is able to respond to the Node.js application to update as needed with a visitor photo and name. When the Node.js application is done with the audio greeting and Tasks, it sends another update to reset the UI.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
      <script src="//www.google.com/jsapi"></script><script src="/socket.io/socket.io.js"></script><script src="https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script><script>// <![CDATA[
         // change for your environment
         var socket = io.connect("192.168.1.103", {port: 3001});
 
         socket.on("proximity", function(message) {
           $('.circle, .circle1').fadeOut('slow', function() {
             console.log(message);
             $('#photo').css('background-image', 'url(' + message.Profile_Photo__c + ')');
             $('#photo').fadeIn('slow');
             $('#username').fadeIn('slow', function() {
                     $('#username').html('Welcome ' + message.FirstName);
             });
           });
         });
 
         // listen for speech to finish
         socket.on("closephoto", function(message) {
         $('#photo').fadeOut('slow');
         $('#username').fadeOut('slow', function() {
           $('#username').html('');
             $('.circle, .circle1').fadeIn('slow');
           });
         });
 
      
// ]]></script>

1
<!-- END LOOP LOADER -->

Arduino Code
This Arduino code combines a Bluetooth scan using code from Jan Stevens, combined with our code from prior proofs connecting the Arduino to Wifi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
/*
Code sample based on the following resources
- Bluetooth Detection http://www.fritz-hut.com/2012/08/26/bluetooth-presence-detection/
- WiFi http://arduino.cc/en/Tutorial/WiFiWebClientRepeating
- HTTP PUT https://www.johnbrunswick.com/2014/01/internet-of-customers-arduino-rfid-http-put-node-js/
*/
#include
#include
#include
#include
 
char ssid[] = "xxxxx"; // your network SSID (name)
char key[] = "xxxxx"; // your network key
 
// Keep track of web connectivity
boolean lastConnected = false;
boolean incomingData = false;
int status = WL_IDLE_STATUS; // the Wifi radio's status
int keyIndex = 0; // your network key Index number
 
// Take care of advoiding duplicate posts
unsigned long lastConnectionTime = 0;
const unsigned long postingInterval = 10*1000;
 
// Removing duplicate posts to Node.js service within certain interval
unsigned long lastReadTime = 0;
const unsigned long pollingInterval = 10*1000;
 
IPAddress server(192,168,1,103);  // numeric IP (no DNS)
 
// Initialize the Ethernet client library
// with the IP address and port of the server
// that you want to connect to (port 80 is default for HTTP):
WiFiClient client;
unsigned long lastTime;
unsigned long interval = 10000;
 
int bluetoothTx = 2;  // TX-O pin of bluetooth mate, Arduino D2
int bluetoothRx = 3;  // RX-I pin of bluetooth mate, Arduino D3
 
SoftwareSerial bluetooth(bluetoothTx, bluetoothRx);
 
String btid;
 
void setup()
{
  Serial.begin(9600);  // Begin the serial monitor at 9600bps
 
  bluetooth.begin(115200);  // The Bluetooth Mate defaults to 115200bps
  bluetooth.print("$");  // Print three times individually
  bluetooth.print("$");
  bluetooth.print("$");  // Enter command mode
  delay(100);  // Short delay, wait for the Mate to send back CMD
  bluetooth.println("U,9600,N");  // Temporarily Change the baudrate to 9600, no parity
  // 115200 can be too fast at times for NewSoftSerial to relay the data reliably
  bluetooth.begin(9600);  // Start bluetooth serial at 9600
 
  Serial.println("------------------");
  Serial.println("Starting - RFID and WiFi POC Test");
 
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
 
  // check for the presence of the shield:
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue:
    while(true);
  }
 
  // attempt to connect to Wifi network:
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to WEP network, SSID: ");
    Serial.println(ssid);
    status = WiFi.begin(ssid, keyIndex, key);
 
    // wait 10 seconds for connection:
    delay(10000);
  }
 
  Serial.println("Connected to WiFi...");
  Serial.println("------------------");
  Serial.println("");
 
  printWifiStatus();
}
 
void loop()
{
    // Get current millis();
    unsigned long currentTime = millis();
    // Check if its already time for our process
    if((currentTime - lastTime) &gt; interval) {
        lastTime = currentTime;
        // Enter command mode
        bluetooth.print("$$$");
                //Wait a bit for the module to respond
        delay(200);
                // Start the inquiry scan
        bluetooth.println("IN,2");
        delay(5000);
        delay(500);
        int h = bluetooth.available();
        if(h &gt;= 42) { // we know there is a bluetooth device
            Serial.println("Someone is near...");
            char *id = readSerial(h);
            char *str;
 
            while((str = strtok_r(id, "n", &amp;id)) != NULL) {
                    Serial.println(str);
 
                      // TODO - find better way to deal with null at end of str
                      // variable to assign for later use as string
                      btid = (String)str;
                      btid = btid.substring(0, 19);
 
                  while (client.available()) {
                    char c = client.read();
                    Serial.write(c);
                  }
                  if (!client.connected() &amp;&amp; lastConnected) {
                    Serial.println();
                    Serial.println("disconnecting.");
                    client.stop();
                  }
                  if(!client.connected() &amp;&amp; (millis() - lastConnectionTime &gt; postingInterval)) {
                    sendData();
                  }
                  lastConnected = client.connected();
            }
        } else if(h &lt;= 21) { // we know there is no bluetooth device
            Serial.println("No device found");
        }
        bluetooth.println("---");
 
    }
    clearAll();
}
 
void clearAll() {
    for(int i = 0; i &lt; bluetooth.available(); i++) {
        bluetooth.read();
    }
}
 
// a bit hacked...
char* readSerial(int h) {
    char input;
    char buffer[100];
    if (bluetooth.available() &gt; 0) {
        int j = 0;
        for (int i = 0; i &lt; h; i++) { // the id's start at char 21, se we copy from there
            input = (char)bluetooth.read();
            if(i &gt;= 21) {
                buffer[j] = input;
                buffer[j+1] = '';
                j++;
            }
        }
        return buffer;
    } else {
        return "No Data";
    }
}
 
void sendData() {
  Serial.println("-----------------&gt;");
  Serial.println("Trying to send card data to server for card " + btid + "...");
 
  // if you get a connection, report back via serial:
  // change port info as needed, this was used with a local instance via Heroku command line
  if (client.connect(server, 3001)) {
 
    Serial.println("Connected to server...");
    String feedData = "n{"mobiledevice" : {"btid" : "" + btid + ""}}";
 
    Serial.println("Sending: " + feedData + "...");
 
    client.println("PUT /checkin/ HTTP/1.0");
 
    client.println("Host: 192.168.1.103");
    client.println("Content-Type: application/json");
    client.println("Content-Length: " + String(feedData.length()));
    client.print("Connection: close");
    client.println();
    client.print(feedData);
    client.println();
 
    Serial.println("Data has been sent...");
    Serial.println("-----------------&gt;");
 
    delay(2000);
 
    lastConnectionTime = millis();
 
    while (client.available() &amp;&amp; status == WL_CONNECTED) {
   if (incomingData == false)
{
          Serial.println();
  Serial.println("--- Incoming data Start ---");
  incomingData = true;
}
char c = client.read();
Serial.write(c);
        client.flush();
        client.stop();
    }
 
    if (incomingData == true) {
      Serial.println("--- Incoming data End");
      incomingData = false;
    }
    if (status == WL_CONNECTED) {
      Serial.println("--- WiFi connected");
    }
    else {
      Serial.println("--- WiFi not connected");
    }
  }
  else {
    // if you couldn't make a connection:
    Serial.println("connection failed");
    Serial.println("disconnecting.");
    client.stop();
  }
 
  // Reset Bluetooth ID
  btid = "";
}
 
void printWifiStatus() {
  // Print the SSID of the network you're attached to:
  Serial.println("------------------");
  Serial.println("WiFi Status...");
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());
 
  // Print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);
 
  // Print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("Signal Strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
  Serial.println("------------------");
  Serial.println("");
}

Node.js Application
The following is the featured method from our Node.js application that uses the Say.js package to provide the audio that speaks a user’s Tasks. We evaluate if any Tasks exist on the basis of a user account containing a Bluetooth ID that matches one that the Arduino has sent.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
...
app.put('/checkin', function(req, res) {
  console.log('PUT received');
  var btid = req.body.mobiledevice.btid;
 
  console.log("Last guest: " + lastguest);
  console.log("New guest : " + btid)
 
  // check to see if speech is already in progress
  if (readytospeak == 1)
  {
 
    if (btid != "001FF3AD6525,380104") {
      guests.push(btid);
 
      // lock the speaking, so we only address 1 guest at a time
      readytospeak = 0
 
      console.log("Guests so far - ");
      //console.log(btid);
 
      guests.forEach(function(entry) {
          console.log("Guest: " + entry);
      });
 
      var taskspeech = '';
      var greetinghour = '';
      var greetinghour = 'afternoon'; // could be dynamic based on time and SFDC user timezone
      var greetingname = '';
      var speechvoice = '';
 
      // Get user info for photo
      var quser = "SELECT Id, FirstName, LastName, Profile_Photo__c, Greeting_Voice__c FROM User WHERE Phone_Code__c = '" + btid + "'";
 
      org.query(quser, oauth, function(err, resp){
        if(!err &amp;&amp; resp.records) {
            // get speech defaults used for audio greeting
            greetingname = resp.records[0].FirstName;
            speechvoice = resp.records[0].Greeting_Voice__c;
 
            io.sockets.emit("proximity", resp.records[0]);
 
            console.log("greetingname: " + greetingname);
            console.log("speechvoice: " + speechvoice);
 
 
            // User the MAC address from the Bluetooth
            var q = "SELECT Id, OwnerId, Description FROM Task WHERE OwnerId IN (SELECT Id FROM User WHERE  Phone_Code__c = '" + btid + "') AND Status = 'Not Started'";
 
            org.query(q, oauth, function(err, resp){
              if(!err &amp;&amp; resp.records) {
 
                var opentasks = resp.records;
 
                var say = require('say'),
                colors = require('colors'),
                sys = require('sys');
 
                var plural = '';
                if (opentasks.length &gt; 1)
                {
                  plural = 's';
                }
 
                // no callback, fire and forget
                say.speak(speechvoice, "Good " + greetinghour + "  " + greetingname + ". You currently have " + opentasks.length + " task" + plural + ".", function () {
 
                  var taskcount = 0;
 
                  opentasks.forEach(function(item) {
                    taskcount += 1;
 
                    // commas add a pause during the speech
                    taskspeech += "Task " + taskcount + ", " + item.Description + ", ";
                  })
 
                  // no callback, fire and forget
                  say.speak(speechvoice, taskspeech, function () {
                    // close the welcome photo on the client side
                    io.sockets.emit("closephoto", true);
 
                    // ready to greet another guest
                    readytospeak = 1;
                  });
 
                });
              }
            });
        }
      });
    }
  }
  else{
     console.log("Speaking is already in process...");
  }
 
  res.send({});
});
...

Download Source
Download Source Code from Github