While I’d like to think I’m a good storyteller and an artist, I’m pretty sure I’m not ‘awesome’ at either. That’s one more reason to pay attention to Augmented Reality (AR) these days.

As an engineer and a designer, I frequently find myself trying to explain a widget, a feature, or a design to someone. Often this takes lots of hand-waving, white-board markers, and innumerable sketches. This got better over time with improved drawing skills and communication techniques. It was even better still when I could put a physical model in someone’s hands by using a 3D printer for rapid prototyping. Well, things just got a lot more interesting when we started using AR through ThingWorx Studio to do virtual prototyping.

While I spend most of my time designing business strategies for the IoT and connecting products using ThingWorx as an IoT platform, the AR portion of ThingWorx is simply fun to use. One great way to employ the tool is to super-impose streaming data and information directly onto the product while looking through a mobile device. AR Prototyping, on the other hand, is the ability to superimpose alternate designs into the real world through a mobile device such that you can experience a design as it was intended. The kicker is that you can whip together a couple dozen designs, review them virtually — in person or remotely — and have a fabulous understanding of the design in less time than it takes to print even one prototype.

In the video below we’re playing with the app ThingWorx View by PTC. Watch this model of a motorcycle come to life with Augmented Reality (AR). We’ve used this technology for virtual prototyping. For some of our customers we are able to swap in and out CAD models to virtually prototype new designs and configurations.

So, if you’re like me and you want to convey a design idea in a hurry — even faster than a rapid prototype — you should really look into AR Prototyping. This has sliced-bread beat no problem.

If you want to start virtual prototyping, ask us how here! We’d love to help you transform the way you design and connect to your products.

I applaud anyone currently considering how the Internet of Things (IoT) can transform their company and their approach to competition. This is what every industrial and consumer product company should be doing right now. While helping companies through the early stages of developing IoT strategies we’ve recognized a common challenge. Teams can get lost in the excitement of enabling their first “thing” and lose focus on their long-term vision and the value they can extract from streaming data. We get it! The IoT is exciting. That is why we always coach our clients to select an IoT platform (software) that allows them to quickly and easily develop applications that present valuable, digestible information to employees and customers – whether or not a role or data stream was part of the initial strategy.
This week provided me with a front row seat to unexpected value from streaming data. While working on an IoT proof of concept for a client, my team was able to refine a data stream and deliver a new application to an audience that was not part of the initial scope of the project. The only reason we were able to create this new application without charging an additional fee is because we selected ThingWorx, a solution by PTC as the application/mashup development tool. Thingworx helps teams create new applications in minutes.

I try to spend the majority of my time working on IoT strategies and how they can transform companies and competition. My background in engineering and software development provides me with a unique view into the time spent making things smart — providing sensor networks, communication layers, and ultimately enabling heretofore unseen analytics in real-time on remote products. The project the Connect Services team and I were working on this week involved developing mashups, which stemmed from earlier strategy work and team alignment. Mashups are the collection and presentation of data from smart things and systems enabling real-time business awareness and decision-making. For this project, we had already developed storyboards for the apps that would enable core product and service differentiation. Everyone was on board and excited.

Once the proof of concept device was wired and streaming data, we saw a whole new role that would benefit from the data that was streaming. Previously, the engineers would have been left hanging and the data would have been left alone and isolated. This is because developing an extra application for ancillary roles would have taken the project well off track. Leveraging ThingWorx as our application development environment, we were able to build a concept from scratch in literally seconds. What’s really cool is that it didn’t take any code at all either, just drag, drop, save, and we were in business. The concept made sense and in literally a couple of hours (not days or weeks) we had created an entirely new app and use case for the data. We were able to refine the data in real-time and create a whole new monitoring experience. Again, this was done without coding, just simply drag and drop.

So, here’s my recommendation — make sure your IoT platform supports your IoT strategy. And what’s more, be sure the platform you select is a tool that is flexible, fast, and fun — like ThingWorx. You will likely find more and more ways to consume, refine, and benefit from the data your connected products and enterprise produce just because it’s easy to do. And this, after all, is what your IoT platform should do — it should enable your existing business initiatives and accelerate your business initiatives.

EAC Connect Services is here to help you develop your IoT strategy, build and connect your proof of concept, and select the appropriate platform. Let us be your partner in the ever-changing world of the IoT. Please let us know if we can help you transform your business and help you beat your competition.

There’s a lot of buzz these days about leveraging the internet and the ‘cloud’ for business — especially in the realms of product development. Phrases like Internet of Things (IoT), Machine 2 Machine, Product as a Service, Internet of Everything, Cloud Things, Connected Products and others get thrown around daily. Regardless of the term you use, the real intent of any of these IoT projects is to generate some additional value. That could be from more capability, deeper customer interaction, predictive maintenance, new revenue streams, market share, knowledge of how the product is being used or many other scenarios. I thought it would be fun to leverage it for gardening!

This time of year, there are a lot of northern gardeners are doing a dance with garden plants they’ve started from seed while winter was still rolling along. Now the seedlings want to be outside in the sun, but its too cold at night. The plants are getting crowded and too big to park in a window in the living room. Build a plastic tent outside as a make-shift greenhouse and it’s too hot during the day. So you’re left with shuffling the plants inside and outside to follow the spring sun and avoid a late frost. But how do you balance this while keeping your day job?

Enter the IoT and a little project in our parking lot… With a little creativity, some parts we had around and a few extra parts from the thrift store, we built an ‘almost’ free greenhouse we can monitor through any web-browser. Our interest at first is simply to monitor the temperature, relative humidity and light level both inside and outside the greenhouse. It’s fun to see the values ebb and flow with the day and with the weather. This was achieved through an Ethernet connected Arduino wired to a photoresistor and a pair of DHT11 Digital Humidity and Temperature sensors. Currently the system feeds into ThingSpeak for graphical representation with plans to port it over to ThingWorx in upcoming days.

Since the sun is hot this time of year but the cold weather isn’t over, we’ll likely experience some high temperature spikes and some cold nights that could damage the tomatoes. This brings up phase 2 — ‘control.’ Our near term plans are to have powered ventilation and heating to kick in either by reaching through the internet or with the internal controller. Eventually we’ll get to a fully autonomous greenhouse that manage temperature, have sensors in the soil monitoring moisture and turning on/off soaker hoses and misting fans all the while keeping us informed on a smart phone. Those are going to be happy tomatoes with their own twitter account…

Maybe all this tech and automation will take some of the fun out of gardening and fiddling with the plants to get it ‘just right’. What’s more likely is that it will just encourage the acquisition of more plants and the need for a bigger garden and a bigger greenhouse with more automation — but that would be fun too…

EAC Product Development Solutions is a Minnesota based company providing engineering and product development software, service and consulting to the discrete manufacturing industry. With 20 years of product development experience, EAC is seeking to help companies that desire to get more from their products through the IoT. We engage in all aspects of product strategy, product design and enabling technology to achieve those goals. Please contact Rob at rmiller@eacpds.com to find out more.

This tutorial is a follow-up to my previous tutorial, “Getting Started with the Arduino Uno and ThingWorx.” Connecting to ThingWorx with the Arduino is easy if you possess an Ethernet or WiFi Shield but you can still connect without one! Using the Processing language you can send data from your Arduino to a computer via a serial connection and push it to ThingWorx.

Requirements:

• ThingWorx hosted instance
• Arduino Uno
• Processing Environment (found at Processing.org)
  
• Arduino Environment

In this post:

• Introduction to Processing
• Tutorial
• Sample Code: ThingWorx Serial Example for Arduino Uno

Introduction to Processing:

Processing is the language that the Arduino language is built on. This means that the syntax is very similar. I would recommend visiting the tutorials and documentation that is provided on the Processing.org site as it is very informative and helpful.

Tutorial:

In order to push data to your ThingWorx thing refer to my previous tutorial, “Getting Started with the Arduino Uno and ThingWorx,” to get a Thing and Service set up. Next, copy and paste the example code that is included with this post. That’s really all you need to do!

More specifically, enter all of your pertinent server and thing information into your processing code. You should now be ready to start pushing data to ThingWorx. Fire up your Arduino and upload the example code to it. Next, push the “play” button at the top of your Processing Environment.

You may run into a few issues. One, if your Processing code throws an error about your serial port (it will say something about a “null exception”) you’ll need to determine which serial port your Arduino is at. The Processing code will print a list of available ports and default to the first one on the list. If your port is different then you can change it in the code:

You can either change the highlighted number to match the position that the port is listed or just change the highlighted variable portName to the actual name of the port:

You will also have an issue if you try and open your Serial Monitor in your Arduino Environment. This will cause your port to become unavailable.

Advantages and Disadvantages: Now that you know how to connect your Arduino to ThingWorx using three different methods, let’s discuss some possible advantages and disadvantages of each. In the case of the Ethernet Shield, you are able to move from one network to another without much issue. No new coding is needed. With the WiFi shield, you must recode your Arduino any time that you switch networks so you can enter the SSID and Security Code if needed. However, once the Arduino is configured correctly, you merely turn it on and it runs as a standalone device.

The serial connection allows you connect to the internet without the use of a shield. The cost of an Ethernet or WiFi shield is typically between $30 and 80$ depending on the manufacturer. A disadvantage is that you must be tethered to the Arduino with a computer if you want to send data.

The Processing language is very easy to learn and there are tutorials on the web that will instruct you on how to build user interfaces that you can control your Arduino with. This makes the serial connection an attractive option if you want some control over pins or variables on your Arduino!

And now for some code…

/***************************************************************************************************
ThingWorx Serial Example for Arduino Uno

This Arduino and Processing code allows you to connect to ThingWorx without the use of an Ethernet
or WiFi Shield.  The data is sent from the Arduino to the computer via the serial (USB) connection
to your computer.  All server and “Thing” data goes into the Processing code that is commented out
at the end of the Arduino Code. When you are running this code do NOT use the Serial Monitor in the
Arduino environment as it will interrupt the Serial connection to Processing.  The Processing language
can be found at Processing.org.

Created by Nick Milleson
Design Engineer
EAC Product Development Solutions
nmilleson@eacpds.com
***************************************************************************************************/

//Make sure that SENSORCOUNT matches SENSORCOUNT in the Processing code
#define SENSORCOUNT 4

double sensorValues[SENSORCOUNT];

//Denote the pins you will be using
int sensorPins[] = {A0, A1, A2, A3};

void setup() {
//begin Serial connection
Serial.begin(9600);

for (int idx = 0; idx < SENSORCOUNT; idx++)
{
pinMode(sensorPins[idx], INPUT);
}

}

void loop() {

//Read info from the pins
for (int idx = 0; idx < SENSORCOUNT; idx++)
{
sensorValues[idx] = analogRead(sensorPins[idx]);
}

//send out a serial message that tells your Processing code that you are beginning a transmission
Serial.println(“begin”);

for (int idx = 0; idx < SENSORCOUNT; idx++)
{
//Send data over the serial port
Serial.println(sensorValues[idx]);
}

delay(1000);
}

/***************************************************************************************************
ThingWorx Serial Example for Arduino Uno

This Arduino and Processing code allows you to connect to ThingWorx without the use of an Ethernet
or WiFi Shield.  The data is sent from the Arduino to the computer via the serial (USB) connection
to your computer.

Enter your Server, appKey, Thing, Service, and sensorNames to match up with the data being sent by
the Arduino.  Make sure that you do NOT use the Serial monitor in the Arduino Environment. It will
disrupt the connection.

Created by Nick Milleson
Design Engineer
EAC Product Development Solutions
nmilleson@eacpds.com
***************************************************************************************************/
/*
import processing.net.*;
import processing.serial.*;

Client myClient;                     // Client object

Serial myPort;                       // The serial port

final int SENSORCOUNT = 4;           // This value must match SENSORCOUNT in your Arduino Code

String sensorValues[] = new String[SENSORCOUNT];
String junk;
String beginString = “begin”;
String myServer = “enter server here”;
String appKey = “enter appKey here”;
String thingName = “enter Thing here”;
String serviceName = “Enter Service here”;
String myURI = “POST /Thingworx/Things/” + thingName + “/Services/” + serviceName + “?appKey=” + appKey + “&method=post&x-thingworx-session=true<“;
String myHost = “Host: ” + myServer;
String myContent = “Content-type: text/htmln”;
String sensorNames[] = {
“valueOne”, “valueTwo”, “valueThree”, “valueFour”
};  //Enter your variable names (these must match the inputs in your Service)

void setup() {

// Print a list of the serial ports, for debugging purposes:
println(Serial.list());

String portName = Serial.list()[0];
myPort = new Serial(this, portName, 9600);

myClient = new Client(this, myServer, 80);
}

int idx = SENSORCOUNT + 2;

void draw() {

if (myPort.available() > 0)
{
junk = null;
junk = myPort.readStringUntil(‘n’);

// look for the initial “begin” string that Arduino sends
if (junk != null)
{
if (beginString.equals(trim(junk)))
{
junk = null;
idx=0;
}
}

//Read each sensor value
if ((junk != null) && (idx < SENSORCOUNT))
{
sensorValues[idx] = junk;
junk = null;
idx++;
}

//When all sensor values have been read, send the info to ThingWorx
if (idx == SENSORCOUNT)
{

myClient.write(myURI);

for (int index = 0; index < SENSORCOUNT; index++)
{
myClient.write(“&” + sensorNames[index] + “=” + trim(sensorValues[index]));
}
myClient.write(“> HTTP/1.1n”);
myClient.write(myHost + ‘n’);
myClient.write(myContent + ‘n’);

println(“Sending this REST call:”);
print(myURI);
for (int index = 0; index < SENSORCOUNT; index++)
{
print(“&” + sensorNames[index] + “=” + trim(sensorValues[index]));
}
print(“> HTTP/1.1n”);
print(myHost + ‘n’);
print(myContent + ‘n’);
print(‘n’);

idx = SENSORCOUNT + 2;
}
}
}
*/