Create a fun, simple IoT accelerometer game

Note:IBM Data Science Experience (DSX) is now IBM Watson Studio. Although the name has changed and some images may show the previous name, the steps and processes in this tutorial will still work.

You can create a fun little game to play with your friends and colleagues. With anyone that has a smartphone you can play a game I call “Harlem Shake.” (Watch us shake it up at a recent DeepLearning meetup.)

Playing is easy: give someone a URL that they access on their smartphone, and then have them shake their smartphone as hard as they can. The person who uses the most energy wins!

What happens behind the scenes is pretty basic: accelerometer data from the smartphone is streamed to the cloud, captured in a database, and then a script calculates the winner. It sounds simple and fun. But, you have to build it first. And you’ll get to learn a lot about MQTT, NodeRED, ApacheCouchDB, and ApacheSpark along the way.

This IoT game, like all IoT apps, requires a complete system to work. In this tutorial, we’ll use IBM Cloud and the IBM Watson IoT Platform services:

• Node-RED, which we use to create the IoT application and which we use to stream the data from the sensor to the database
• IBM Watson IoT Platform, which we use as the MQTT message broker to hold it all together
• Cloudant, a NoSQL database system that we use to store the data
• An ApacheSpark SQL script, which we run in IBM Watson Studio, that tells you who wins

Obviously, all the smartphones will act as the sensors, streaming the data into our IoT app.

You can build the game in six steps:

• Deploy the game application using one-click deployment.
• Replace the Internet of Things Platform service.
• Ensure the MQTT message broker can receive data.
• Set up a NoSQL database to store the data.
• Stream the data to Cloudant using Node-RED.
• Analyze the data in a data science notebook.

What you’ll need to build your app

• An IBM Cloud account. (Sign up for an IBM Cloud Lite account, a free account that never expires.)
• A smartphone. Or, one or more friends with smartphones to play the game with you.
• An IBM Watson Studio account. You can use the IBM ID you’ve created while registering for the IBM Cloud Account. To get started using IBM Watson Studio, including signing up for an account, watch the videos in this video collection.

After you have an IBM Cloud account in place, you can deploy the application in just one click. You’ll have to set up the deployment manually. I’ve created a sample IoT game app for you and put in on Github for you to download.

1. Log in to your IBM Cloud account.
2. Go to my discover-iot-sample repo in GitHub, and in the README instructions, click the Deploy to IBM Cloud button.
3. In IBM Cloud, click Deploy.
4. Click the Deliver Pipeline tile.
5. In the Deploy Stage tile, click the gear icon, and then select Configure Stage.
6. Select the Input tab, change the Input Type to Git Repository, and then click Save.
7. In the Build Stage tile, click the Run icon (next to the gear icon).
8. After awhile, in the Deploy Stage tile, you should see the URL of your application in the Last Execution Result section. Click the URL. The URL that you need to play the game on a smartphone is displayed.
9. Copy the URL (and either create a short URL or a QR code for the URL), and email it to yourself. You’ll use this link later to play the game.

While you can now send accelerometer data to the cloud, it won’t get stored. Next, we need to set up data storage.

After you deploy the game app, you need a way to get the accelerometer data to the cloud. To get the data to the cloud, you’ll use Node-RED, which is an open-source graphical flow editor. You use Node-RED to subscribe to the MQTT data that is coming from the smartphone and being stored to the database in the cloud. However, before we can get to Node-RED, we need to replace the default platform service with the service that I’ve included as part of the app that we’ve just deployed.

The Internet of Things Platform Starter boilerplate contains a Node-RED engine that you will use to process IoT messages. First, you need to remove the default Watson IoT service from the starter.

1. You should already be logged in to your IBM Cloud account. If not, log in.
2. Go to the Internet of Things Platform Starter in the IBM Cloud catalog. (Alternatively, you can navigate to this Starter by selecting Catalog > Boilerplates > Internet of Things Platform Starter.)
3. In the App name field, enter a unique name for your app, such as myharlemshake, and then click Create.
4. Wait until the status changes from Starting to Running.
5. From the menu on the left, click Connections.
6. For the default Internet of Things Platform service, click the menu in the upper right corner, and then click Unbind service .
7. In the pop-up message that displays, select Delete this service instance, and then click OK.
8. When prompted to restage your app, click Cancel.

Now that you’ve deleted the default iotf-service-free service, you need to create a connection to the deployed game application’s IoT service and set the correct security level.

1. Click the Connect existing button.
2. Select discover-iot-try-service, and then click Connect.
3. When you are prompted to restage your app, click Restage.
4. Wait until the status changes to Running.
5. Click discover-iot-try-service, and then click Launch. This starts IBM Watson IoT Platform in the IBM Cloud.
6. Hover over the column of icons on the left. From the left menu, select Security.
7. Edit Connection Security.
8. In the Default Rule section, under Security Level, select TLS Optional, and then click Refresh compliance.
9. At the top of the window, in the upper right, click Save .

Now that we’ve successfully connected to the IoT service that I provided in the game app, we need to use Node-RED to store the sensor (accelerometer) data in the cloud.

Before you can open Node-RED, you must configure a user name and password for accessing Node-RED flows in your app.

1. You need to return to the Cloud Foundry Apps page for your game app. In your browser, locate the Service Details tab. From the hamburger menu, select Cloud Foundry Apps.
2. From the table, select the name of your game app.
3. From the left menu, select Connections.
4. To the right of the status, click Visit App URL. The URL should be your app name followed by mybluemix.net (for example, https://myharlemshake.mybluemix.net). Note: Write down this URL because you can use it to open your Node-RED instance.
5. To secure your Node-RED instance, click Next.
6. Choose a user name and password. Make a note of it. Click Next.
7. Click Finish.
8. Click Go to your Node-RED flow editor.
9. Enter your user name and password to log in to Node-RED.

Now you have everything in place to capture and store the data. You have deployed your game app, and you’ve created a connection between your game app and the message broker. The communication channel is working, but you need a place to store the data you will be sending.

Now that we can access Node-RED, let’s double-check if data that is coming from your smartphone arrives in the cloud (the MQTT message broker is a service that is part of the IBM Watson IoT Platform).

We need to use Node-RED to subscribe to the data stream. We will do any debugging of the service using the Node-RED debug panel.

1. You should already have your Node-RED instance open from the last section. If not, open the Node-RED instance using the Visit App URL that you wrote down when you started the Node-RED engine earlier. Log in to your game app’s Node-RED instance using the user name and password you assigned yourself.
2. To delete all existing nodes in the default flow, select them all, and then press the Backspace or Delete key. (Note: The keyboard shortcut CTRL-A doesn’t work to select all the nodes.) A blank canvas is then displayed.
3. From the left palette, select and drag the IBM IoT input node (don’t use the output node) and the debug output node to the right pane. Connect them by selecting a connection circle on a node and dragging it to the other node’s connection circle.
4. Double-click the IBM IoT node.
5. For Authentication, select IBM Cloud Service, and click Done. This tells the node to get the credentials to connect to the MQTT broker using Cloud Foundry credentials injection, which is a very handy feature because in IBM Cloud the application that you deployed is connected to the MQTT broker (that is, the Watson IoT Platform service).
6. Click the Deploy button.
7. On the right side of the panel, under the Deploy button, select the debug tab.
8. On your smartphone, open the game app using the App name that you created in Section 1. In my case, it is discover-iot-sample-romeokienzler-1412.mybluemix.net/iot-phone
9. Provide an 8-character alphanumeric name; for example, qwer1234.
10. Provide an 8-character password that only contains alphabetic characters between a-z. In Node-RED on the debug tab, you should see debug output.

Another way to see the accelerometer data is to look at a list of all game players.

1. Open the IBM Watson IoT Platform. From your Cloud Foundry Apps view, click the discover-iot-try-service, and then click Launch.
2. From the left menu, select Devices.
3. Click a device, and then double-click a sensorData event to see more detail.

Congratulations, we are almost done. You’ve verified that data can be streamed from a smartphone by using the MQTT message broker in Watson IoT Platform to our Node-RED app. The next step is to stream this data to a database and analyze it.

When we play Harlem Shake we are sending IoT sensor data through an MQTT message broker in the cloud. We need to send it to a NoSQL database. Let’s add the database function.

1. You should already have your Node-RED instance open from the last section. If not, open the Node-RED instance using the Visit App URL that you wrote down when you started the Node-RED engine earlier. Log in to your game app’s Node-RED instance using the user name and password that you assigned yourself.
2. From the left panel, drag the function node in between the other two nodes, which will automatically connect it to those nodes.
3. We first have to flatten the hierarchical JSON messages to a relational scheme. Double-click the function node, and paste in the following JavaScript code.

   
   msg.payload =
   {
   X : msg.payload.d.ax,
   Y : msg.payload.d.ax,
   Z : msg.payload.d.ax,
   SENSORID : msg.payload.d.id
   }
   return msg;
   

   Show more
   
   The final result should look like this.
4. Click Done.
5. Click Deploy. On the debug tab, the output should look similar to this.

Now that we’ve added the NoSQL function, we are prepared to store the data in Cloudant.

We’ll be using ApacheCouchDB powered by IBM Cloudant to stream the data to the NoSQL database function we just created. Cloudant is based on open-source ApacheCouchDB, and we will use it store our intermediate sensor data.

1. From the left panel, in the storage area, choose the cloudant out storage connector (the cloud icon is on the right), and connect it to the output of the function node.
2. Double-click the cloudant out node, and select your database Service. Note: There should only be one database service unless you’ve connected more than one Cloudant database to this application in the IBM Cloud console. (Again, the IBM Cloud here is making use of Cloud Foundry credential injection basically doing the job of configuring the database endpoint for you.)
3. Name the database harlemshake.
4. Select Only store msg.payload object.
5. Click Done.
6. Click Deploy.

Now it’s time to check if data arrives in the table. Ensure the game app on your smartphone is still sending data by looking at the debug pane in Node-RED.

Everything should look good. The smartphone shakes, the data streams up to the cloud, and the database is holding the data. But who is keeping score? Something needs to analyze the data and announce the winner. We’ll be using IBM Watson Studio.

1. Log in to IBM Watson Studio.
2. Add a Spark service to your project. Then, create a notebook and select the Spark service. Follow the steps in this tutorial.
3. On the New notebook dialog, click From URL, in the Name field add a name. Then, in the Notebook URL field, paste the following URL: https://raw.githubusercontent.com/romeokienzler/developerWorks/master/boomboomshakeshakesparkv2.ipynb
4. Click Create Notebook.
5. To create a new data source connection, click the Find and Add Data icon > Connections > project page.
6. Click Connections > Create Connection.
7. In the Name field, specify a name, and then under Service Instance, select the database. Click Create. Note: Only one Cloudant database from your previously installed Node-RED boilerplate should be listed.
8. Go back to your notebook and reload. You can now see the connection. Select the first empty cell in your notebook, and click Insert to code. The credentials have been created, and you can start running the notebook.
9. Click Cell > Run All.

After you and your friends have played the game, you can check to see who won. In your notebook, look for the spark.sql statement. It looks like “Seb” is the winner with the most energy input.

Understanding the data science behind the results

What the spark.sql statement does is to approximate the energy that your players generated over the run of the game by calculating the overall energy across all three dimensions of the accelerometer data.

On a single axis, the vibration data time series looks like the following graph:

If you want to know the energy represented by this time series, you can approximate this value by taking the integral of the function.

Remember that we got rid of the negative values and turned them into positive ones. To approximate the integral, we just sum up all the individual positive values.

Now that you’ve learned how to approximate the integral of a time series, let’s calculate the overall energy of all three dimensions (remember, we have three individual signals for each dimension of vibration) using the following formula:

We sum the square of each measurement and take the square root.

Note: To obtain real energy we would need to incorporate mass of the device too.

Using SQL, this calculation is represented by the following statement:

select 
    id, // select ID of the device because we need to know who the winner is
    sqrt(sum(axax+ayay+az*az)) //calculate energy
  as energy  // give this new feature a name
    from unconfshake // specify temporary query table of ApachSparkSQL
    group by id // calculate on a per device basis
    order by energy desc // make top performers appear on top

Conclusion

You’ve done your part and built the game. Now it’s time to play.

1. Find a friend or colleague with a smartphone. Give your friend the game app URL.
2. They need to enter their own unique 8-digit alphanumeric ID and a unique 8-digit character alphabetic password (a-z).
3. Ask your friend to shake the smartphone in all directions. This sends data to the cloud. You can verify this in Node-RED and in Watson Studio using the SQL query provided in the notebook you’ve imported. Just re-run the cell containing the SQL statement once in a while, and you’ll notice how the list of winners changes over time.
4. You can check for the winner by clicking Cell > Run All in the data science notebook.

To play again, you have to complete the following steps:

1. Rename the destination database (harlemshake) in Node-RED, and then update the name in the notebook.
2. Open the IBM Watson IoT Platform again, select all devices, and then select Delete devices.

Note: You could delete the results in the database to play again, but it’s easier to rename the database and reset the connection.

This game can be left up and running so you can play it during your lunch breaks to stay awake after a heavy meal!