The Internet of Things (IoT) is transforming the way companies design, manufacture, and service their products and manufacturing floors. ‘Service’ is one of the most notable areas to be impacted by this wave of technology and connected devices. Monitoring assets in the field and on the shop floor gives service technicians access to usage, error, and predictive analytics prior to a repair. As companies continue to adopt the IoT, more organizations are satisfying the prerequisites to easily deploy augmented reality for service.

With the convergence of the digital and physical worlds, manufacturers are using augmented reality as a tool to help improve their service capabilities. Augmented Reality (AR) can deliver the right information at the very moment that it’s needed on the manufacturing floor so that field service technicians and other factory workers can reduce errors, enhance efficiencies, and improve productivity. AR also allows for content to be presented in arguably the most contextual way possible. When accurate information is presented over real-world devices there is little room for error and misunderstanding.

If field service technicians aren’t available to be on-site for a critical situation, then technicians can remotely assist customers with the help of AR. Customers will be able to observe service manuals with interactive 3D animations to disassemble components or work on equipment with which they’re unfamiliar with. If the users need further help, then the experienced field service technician can walk users through instructions while steaming the user’s device view in real time.

Augmented Reality Barriers to Entry

Your service and parts information have to be accurate and up-to-date in order to fully benefit from an augmented reality investment. Making sure your organization has a reliable Service Lifecycle Management system in place is the first step to digital transformation. Without accurate information on parts and equipment, field service technicians could replace the wrong part or be confronted with an outdated, undocumented design.

In order to be labeled a “smart connected enterprise,” a company should have a strategy to connect all of their assets and data; this includes technical publications. Connected technical illustrations have the power to show the current status for every part and piece of equipment. For example, if a mechanic could see a 3D representation of a vehicle’s carburetor and view critical metrics it would help them understand the potential for repairs or future failure.

Your organization needs to be IoT ready – meaning that there needs to be a strategy in place to input sensors on products and equipment. The Internet of Things allows products and assets to send alerts to a maintenance system that assigns a field service technician to perform a repair. Without the sensors that relay information about the status of those parts, and accurate 3D representations, augmented reality devices would be useless because there would be no relevant or up-to-date information to leverage in the field.

The IoT and Augmented Reality are transforming service and enhancing the field service process. Check out EAC’s solutions to see how you can start using AR today.

Here’s how connected products are changing service.

Connected products optimize business processes

Lets face it, business is all about efficiency – taking costs and time out of products and processes. This is exactly how connected products optimize business processes.

Connected products provide organizations with access to real-time data that is combined with existing system information to increase efficiency.

For example, you could provide data about your products condition in the field. By doing so, your technicians can be better prepared to troubleshoot. This can reduce the number of onsite visits because technicians have the right instructions or tools required to quickly repair an asset.

Implementing a connected product strategy can improve your first-time fix rate, decrease truck rolls and service calls, and increase the efficiency of your delivery model.

Connected products improve customer experience 

Connected products also positively impact customer experience.

Customers recognize more service value when issues are resolved in one call or service visit. Connected products arm your service team with the information necessary to quickly and effectively address service requests and increase customer satisfaction.

Customer satisfaction correlates to service renewals.

Connected products differentiate offerings

With the use of a connected product platform, your organization will be able to increase the pace of product and service innovation, proactively diagnose and service your products all while increasing the speed of your service delivery.

For instance, if your hardware was a commodity or under heavy competitive pressure, improving the software, applications, and service that came along with your products could help differentiate your offering and help you outpace the competition.

Connected products drive new revenue streams

Connected products help drive new revenue streams by unlocking new business models, reducing customer downtime, meeting SLA’s, and by providing offerings such as “product as a service”. Would your company rather wait for occasional service revenue to come in, or would you rather intelligently monitor, maintain, and update your products for a consistent recurring fee?

Information will fuel the future of products and services. Data can be used to improve, differentiate, and optimize your business. The impact the Internet of Things has had on service delivery and customer experience is staggering. Delivering connected products is the first step to realizing the benefits of a connected product service strategy. We’d like to help you realize your strategy, implement industry-leading solutions, and support your implementation and deployment. Let’s connect.

One of the great aspects of ThingWorx is the ability to connect disparate data silos to a central IoT hub. Many of these silos are made accessible through Web APIs. RESTful Web APIs enable developers to pull data from an inexhaustible number of sources around the web; often using nothing but a HTTP URI. Salesforce has an extensive REST API that can be accessed through ThingWorx. This blog will introduce you to creating a “Connected App” on Salesforce, authentication using username and password in ThingWorx, adding records to Salesforce, and finally modifying records. For a detailed description of Salesforce’s REST API, visit https://developer.salesforce.com/page/REST_API

Step 1 (Optional): Obtain a Developer Environment with Salesforce.com

If you do not already have a Salesforce account, navigate to https://developer.salesforce.com/platform/force.com and sign up for a free developer environment. It only takes a few minutes and you get a fully functioning Salesforce instance that you can freely develop in.

Step 2: Obtain a Security Token

You’ll need a security token to authenticate with a username and password. If you don’t already have one, or can’t dig it up from previous emails, you’ll need to reset the token.

Resetting the Token

1.    In the upper right-hand corner of your Salesforce page, click on your name and select “My Settings”

2.    On the left-hand menu, select “Personal”

3.    Under “Personal,” select “Reset My Security Token”

4.    Follow the directions on the page and you will receive a new security token via email

Step 3: Create a Connected App

To use the REST API, we’ll need to create a connected app that gives us a “Consumer Key” and a “Consumer Secret”.

Creating the Connected App

1.    Click on “Settings” in the upper right of your Salesforce screen

2.    On the left side, navigate to “Build” > “Create” > “Apps”

3.    Under the “Connected Apps” section, select “New”

4.    Fill out the fields as shown below. A callback URL is required but we won’t really be referencing it anywhere in ThingWorx. There is a great article on using Postman to test out REST calls with Salesforce at https://blog.mkorman.uk/using-postman-to-explore-salesforce-restful-web-services/ . The callback URL is used in the examples when authenticating in Postman.

5.    Click “Save.” You will get an alert that your connected app will take 2-10 minutes to take effect.

6.    After you click “Save,” you’ll see the “Consumer Key” and “Consumer Secret.” Copy those somewhere to use in ThingWorx.

Step 4: Authenticate Salesforce Session in ThingWorx

In this step, we’ll create a service in ThingWorx that returns a JSON for us to use in our other Salesforce requests.

1.    Create a service inside your Thing called AuthenticateSalesForce. I have a “TestThing” that I’ve created where I can try out new services without disrupting any of my live projects.

2.    Choose the “STRING” type for the result output, no inputs are needed unless you want to have the end user input their username and password. After we test functionality, we’ll change the output type to “JSON”

3.    Enter the following code, which is just the POST JSON function in the ContentLoaderFunction resource.

var params = {

                 proxyScheme: undefined /* STRING */,
                 headers: undefined /* JSON */,
                 ignoreSSLErrors: undefined /* BOOLEAN */,
                 useNTLM: undefined /* BOOLEAN *
                 workstation: undefined /* STRING */,
                 useProxy: undefined /* BOOLEAN */,
                 withCookies: undefined /* BOOLEAN */,
                 proxyHost: undefined /* STRING */,

url: "https://login.salesforce.com/services/oauth2/token?grant_type=password&client_id=&client_secret=&username= &password=" /* STRING */,

                 content: undefined /* JSON */,
                 timeout: undefined /* NUMBER */,
                 proxyPort: undefined /* INTEGER */,
                 password: undefined /* STRING */,
                 domain: undefined /* STRING */,
                 username: undefined /* STRING */

};

// result: JSON
var j = Resources["ContentLoaderFunctions"].PostJSON(params);

var result = j.access_token;

4.    Enter the consumer key, consumer secret, username (use %40 for the ‘@’ symbol), and password plus security token (enter your password and security token with no spaces between the two)

5.    Select “Done” on your service, save your Thing, and test the service. You should receive a session token like the one seen below:

6.    If nothing shows up, either the Salesforce server hasn’t activated the app, or there may be an issue with the URL. If you copy and paste the URL into PostMan, you should get an error message that clarifies the issue.

7.    When you’re getting an access token as the result, edit your service, change the result type to “JSON,” delete the last line (the “var result = j.access_token” line”), and modify the end of the service to now read:

// result: JSON

var result = Resources[“ContentLoaderFunctions”].PostJSON(params);

Step 5: Create a record in Salesforce

In this step, we’ll create a new account within salesforce using our new authentication service and a REST call utilizing the ContentLoaderFunctions.

1.    Create another new service in your Thing and call it AddSalesForceAccount. 2.    Create an input and call it AccountName. The type is “STRING” 3.    Type in the following code:

var authJSON = me.AuthenticateSalesForce();

var token = authJSON.access_token;
var instance_url = authJSON.instance_url;

var url = instance_url + "/services/data/v20.0/sobjects/Account/";

var authString = "Bearer " + token;
var headers = {
   "authorization" : authString,
   "content-type" : "application/json"
};

var content = {
 "Name" : AccountName
};

var params = {
                 proxyScheme: undefined /* STRING */,
                 headers: headers /* JSON */,
                 ignoreSSLErrors: undefined /* BOOLEAN */,
                 useNTLM: undefined /* BOOLEAN */,
                 workstation: undefined /* STRING */,
                 useProxy: undefined /* BOOLEAN */,
                 withCookies: undefined /* BOOLEAN */,
                 proxyHost: undefined /* STRING */,
   url: url /* STRING */,
                 content: content /* JSON */,
                 timeout: undefined /* NUMBER */,
                 proxyPort: undefined /* INTEGER */,
                 password: undefined /* STRING */,
                 domain: undefined /* STRING */,
                 username: undefined /* STRING */
};

// result: JSON
var result = Resources["ContentLoaderFunctions"].PostJSON(params);

4. Test the service. Enter a unique account name and verify that it shows up in Salesforce.

Step 6: Retrieve a Record ID

To modify a record, the record ID must be used to reference the object of interest. We can make a request to Salesforce to return relevant records using an SOQL query. This example will cover retrieving the record ID of the account we just created in the last step.

1.    Create a new service in your Thing

2.    Create an input and call it AccountName. The type is “STRING”

3.    Type in the following code:

var authJSON = me.AuthenticateSalesForce();


var token = authJSON.access_token;
var instance_url = authJSON.instance_url;

var url = instance_url + "/services/data/v20.0/query/?q=SELECT+name+FROM+Account+WHERE+name+=+'" + AccountName + "'";

var authString = "Bearer " + token;
var headers = {
   "authorization" : authString,
   "content-type" : "application/json"
};




var params = {
                  proxyScheme: undefined /* STRING */,
                  headers: headers /* JSON */,
                  ignoreSSLErrors: undefined /* BOOLEAN */,
                  useNTLM: undefined /* BOOLEAN */,
                  workstation: undefined /* STRING */,
                  useProxy: undefined /* BOOLEAN */,
                  withCookies: undefined /* BOOLEAN */,
                  proxyHost: undefined /* STRING */,
                  url: url /* STRING */,
                  timeout: undefined /* NUMBER */,
                  proxyPort: undefined /* INTEGER */,
                  password: undefined /* STRING */,
                  domain: undefined /* STRING */,
                  username: undefined /* STRING */

};




// result: JSON
var j = Resources["ContentLoaderFunctions"].GetJSON(params);

var result = j.records[0].attributes.url;

4. Give the service a name and test it. The output of this service is a url that can be appended to the instance_url that is returned in the response from the Authentication service.

Step 7: Modify a Record

Using the output from our last service, we can now easily modify the fields of the record ID that we just retrieved. Keep in mind, if you create a custom field and you want to modify its value, add a “__c” to the end of the field name (denotes custom field).

1. Create a new service in your Thing
2. Let’s give it a few “STRING” inputs: field, stringValue, and AccountName
3. Input the following code:

var authJSON = me.AuthenticateSalesForce();

var token = authJSON.access_token;
var instance_url = authJSON.instance_url;

var stringJSON = '{"' + field + '":' + stringValue + "}";


var params = {
                  AccountName: AccountName /* STRING */
};

// result: STRING
var object_url = me.RetrieveSalesForceAccountRecordID(params);

var url = instance_url + object_url + "?_HttpMethod=PATCH";
var authString = "Bearer " + token;
var headers = {
   "authorization" : authString,
   "content-type" : "application/json"
};

var content = JSON.parse(stringJSON);

var params = {
                  proxyScheme: undefined /* STRING */,
                  headers: headers /* JSON */,
                  ignoreSSLErrors: undefined /* BOOLEAN */,
                  useNTLM: undefined /* BOOLEAN */,
                  workstation: undefined /* STRING */
                  useProxy: undefined /* BOOLEAN */,
                  withCookies: undefined /* BOOLEAN */,
                  proxyHost: undefined /* STRING */,
                  url: url /* STRING */,
                  content: content /* JSON */,
                  timeout: undefined /* NUMBER */,
                  proxyPort: undefined /* INTEGER */,
                  password: undefined /* STRING */,
                  domain: undefined /* STRING */,
                  username: undefined /* STRING */
};
// result: JSON
var result = Resources["ContentLoaderFunctions"].PostJSON(params);

A Note About Security

Salesforce has a few ways to authenticate your session.  The method described in this blog is the least secure way because ThingWorx has visibility to the username and password of the Salesforce account.  There are two other ways to authenticate and both use callback URLs.  Basically, a user sends a call to the login endpoint and enters user and password information directly into the Salesforce environment.  Salesforce then redirects to a callback URL that is appended with an authorization token.  If you’d like to implement one of the more secure methods, I would suggest using a REST endpoint to a ThingWorx service as your callback URL. More specifically, create a service that has a string input called “code.” Now, change your callback URL in your Salesforce connected app to something like https://login.salesforce.com/services/oauth2/authorize?response_type=code&client_id=&redirect_uri=>.  Now, when you navigate to the login link, it will send your authorization code to your ThingWorx service (this is because it appends “&code=” to the URL).  You’ll need to then send that code via the Content Loader Functions to receive your authorization token.  One thing to note is that the ThingWorx instance must be on HTTPS.  Salesforce does not allow HTTP callback URLs.  More information about Authentication can be found at https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/intro_understanding_authentication.htm

If you have any questions about this blog or ThingWorx in general, don’t hesitate to leave a comment or contact EAC Product Development Solutions.

This is a brief tutorial that will show you how to connect your Arduino Uno to ThingWorx and upload values to a ThingWorx “Thing.” First you will learn how to set up a ThingShape, a Thing, a Service within your ThingShape, and an Application Key. Next you will learn how to program your Arduino Uno to start sending data to your ThingWorx Things! Two simple ThingWorx libraries along with example codes are included with this tutorial. They will allow you to start pushing data in minutes!

Requirements:

• ThingWorx hosted instance
• Arduino Uno
• Ethernet or WiFi Shield with corresponding libraries
• Arduino Environment

In this post:

• Tutorial 1: Setting Up your ThingWorx Thing
  1. Create an Application Key
  2. Create a ThingShape and Service
  3. Create a Thing
  4. Test your Service
• Tutorial 2: Programming your Arduino
  1. Programing your Arduino
  2. Arduino ThingWorxWiFi Library (5.2 KB .zip)
  3. Arduino ThingWorxEthernet Library (4.9 KB .zip)

Tutorial 1: Setting up your ThingWorx Thing

In order to start pushing data to ThingWorx, we must first define our ThingShape, service, Thing, and Application Key.

1: Create an Application Key

An application key is the authentication that you use to send or receive data from your Thing. It is associated with a ‘tag’ that is common to all of the components of your thing. To create the key first get to the home page of your ThingWorx Composer.

1.1:   Under the “Security” heading on the left click on “Application Keys.”

1.2:   Next, click on the “New” button towards the top of the screen. Fill in the required fields

1.3:   Now, create a tag by clicking on the wand next to tags. Either choose an existing tag or create a new one. The tag ties your application key to all the components of your Thing.

1.4:   After selecting a tag click Save at the top and you will see that an Application Key has populated the “keyId” field.

2: Create a ThingShape and Service

2.1:   From the ThingWorx Composer home page select Thing Shapes on the left side of the page under the “Modeling” heading.

2.2:   Next select “New” at the top of the screen and fill out the required fields.

2.3:   Make sure your tag matches the tag you used when creating your Application Key. On the left side of the screen select “Properties.”

2.4:   Select “Add My Property” to start adding Properties to your ThingShape. These are the values that you will be pushing to the ThingWorx site via your Arduino’s ethernet or wifi shield. Select “Number” as the type. You should have a Properties page that looks something like this:

2.5:   Now we’ll create a service that reads values from your Arduino and populates your Properties with them. First, while still in the ThingShape edit mode, click on Services on the left hand side and select the “Add My Service” button at the top.

2.6:   Fill in the Name and Description, then click on Inputs/Outputs.

Add inputs that correspond to the data values that you are sending from the Arduino. These input names MUST match the names that you select in your Arduino code (discussed later). Also make sure that the type is set to STRING. Next, we need to write a short JavaScript that will convert the string values to type float and then populate the properties. Note below that properties will have a “me.” in front of them.

2.7:   Click the Done button at the bottom and then the Save button at the top to complete your ThingShape and Service.

3: Create a Thing

3.1:   From the Composer home page click “Thing” and then click “New”. Populate the required fields. Make sure your tag is the same one you used for your ThingShape and Application Key. Choose the “GenericThing” as your Thing Template. Choose the ThingShape that you just created as your implemented ThingShape.

3.2:   Now click Save and you’re done with your Thing!

4: Test your Service

4.1:   While you are still in your Thing you can now test the service you made by clicking on Services on the left side of the screen. If the Service doesn’t show up then click save again on your Thing and ThingShape and close and reopen your Thing tab. The screen should look something like the one below when you click on Services.

4.2:   Click the “Test” button on the Service that you just created and populate the fields. Click Execute Service.

4.3:   Now exit out of that window and go to your Properties tab on the left and refresh the properties. The values should have populated into your properties!

If the properties didn’t update or you got a JavaScript error, be sure to check back through your Property names, types, and JavaScript code and ensure that it matches the formats from above.

Tutorial 2: Programming your Arduino

Included in this tutorial are two Arduino libraries, called ThingWorxWiFi (5.2 KB .zip) and ThingWorxEthernet (4.9 KB .zip). They also come with example programs. Download these libraries and place them in the /Arduino/libraries folder. Open up your Arduino Environment and under File/Examples, find the Example code for the particular hardware you are using (either WiFi or Ethernet shield). This tutorial will walk you through the Ethernet code. The WiFi code is almost identical save for the required WiFi network information. When you open the code it should look like this:

Make sure you denote how many values you will be pushing to ThingWorx (next to the #define sensorCount). Now fill in the required info: a unique MAC address, server, app key, thing name, service name, the names of your values or sensor values (these must match your Service variables exactly!), the time between connections, and the corresponding pins that your sensors are on. This is all you need to start pushing values! The code as written will send your raw (0 to 1028) analog to digital converted values to ThingWorx. You may choose to process your data into usable values before you send it off. If so, either modify the values in this loop:

Or however you see fit.

Creating Ideal Translation Workflows for Optimum Results 

In Part Two of this post on coupling products for translation, we’ll discuss the specific steps that are required to implement complete translation projects – from managing technical content objects to managing costs and file collaboration. Refer to Part One for the overall solution design which shows the strengths of PTC’s Translation Manager, Windchill ProjectLink, workflow, reporting, and multi-lingual publishing and how they can be leveraged for translation.

The Process 

There are six process components to the overall translation solution. The process starts and ends with PTC’s Translation Manager. Windchill ProjectLink is nested in the middle of the process to facilitate the business project, cost collaboration, and file transfers with Translation Service Providers.

Step 1. Designate Objects for Translation 

The first step of the process begins with source content that is ready for translation to the target language(s). The content is stored in Product or Library folders in Windchill/Arbortext Content Manager. Here the project owner identifies complete document structures or document objects to be translated. A translation work package is created for the objects. The Translation Service Provider and target language(s) are designated with the creation of the translation package. Languages and Translation Service Providers are configurable.

At the completion of this step, the content is prepared for translation. It results with a collection of XML objects to be translated in a zip file. The source objects are set to the In Translation lifecycle state and the source content continues to be managed in relation to other content and states.

Step 2. Create Translation Project 

In the second step, ProjectLink is used to create a translation project that contains any business-related activity required for traceability. This activity includes deadlines and due dates, assign internal resources to the project, and expose the project to Translation Service Provider(s) or other external users outside your firewall. Any cost information, such as Requests for Quote and quotations received can also be stored under the project.

To start, the translation zip package is posted to the project. From here, the package is available for workflow and lifecycle activities as well as for collaboration with Translation Service Providers. If a process for approving translation costs is required, the cost approval workflow would be executed on the translation package stored in the project. Providers will be able to see the source content in order to estimate the level of effort and designated project participants can see cost approved or not approved activity.

Step 3. Route Objects for Translation 

This step in the workflow is for actual translation activities. Here Translation Service Providers can:

1. Checkout and Download the package when it is ready to translate and
2. Checkin and Upload the package when the work is complete.

This activity makes use of the translation package on ProjectLink so that collaboration with users outside your firewall can work on the project. The user interface is self-serving and provides traceability out-of-the-box. The zipped file is automatically iterated and historical versions are maintained on checkin so that everyone on the project is aware of the project status. Users can schedule alerts to immediately know when a critical threshold is reached. Therefore having the lifecycle states in ProjectLink enables real-time reporting on activities to show key performance indicators. Is the project on time? On budget?

Step 4. Route Translated Collateral for Approval 

The approval workflow activity in step four supports reviewing translated content delivered by the Translation Service Provider. Reviews may be performed by local native language review teams or it may include users that have other roles on the project. This activity uses the translation package on ProjectLink so that collaboration for users inside or outside of your firewall can continue to work on the translation. As a result of this workflow, updates can be made either by the Translation Service Provider or by home team members.

Once the translation is approved, the translation project can be concluded and all ProjectLink activities closed. Even so, an organization may still elect to store invoices and final cost information in the project for matrix reporting and future planning purposes.

Step 5. Store Objects in Translation Library 

After objects are translated, the final translation zip package is returned to the Translation Library where XML objects and images are stored. Here the translated target objects are bound to specific revisions and iterations of source objects for each language. For clarity on object status, objects are marked “Translated” or “Translated, Ready for Publish”.

When the objects are returned to Windchill/Arbortext Content Manager they can be published, updated, and iterated just like any other object. This is important since changes may be necessary to:

1. validate the markup;
2. facilitate aesthetics for publishing;
3. change product names, service marks or other marketing decisions;
4. change dates or other metadata.

Step 6. Route Assembled PDF Document for Approval 

In an environment with shared document components, status checks are necessary to verify that all objects included in the document are ready for publishing. This is a key element of the process since some objects may be In Translation, others may be at earlier iterations with no recent updates, or they could be universal images that require no translation. When all objects in the translated document are Ready for Publish, the published document is created, and routed for review and approval. This may be the first time that a translated document is being reviewed as a whole, thus it may be the first time that all content is reviewed relative to the content around it. At this point, it is expected that any changes made during this stage would be made by the home team for content stored securely behind the firewall.

The document review and approval process should be the same as your usual published document review process with different resources for languages. Documents can contain a single language or there may be multiple languages per document depending on the style guidelines for your organization.

Summary

For anyone that has been involved in the translation process, you can likely sympathize on how complex and challenging the tasks can be. By putting ProjectLink to work in your translation process, it does not have to be the case. With PTC’s Translation Manager and Windchill ProjectLink, workflow activities can be more transparent, helping to streamline the translation process across all documents and languages that need to be managed. If you have questions about how ProjectLink, Translation Manager, or multi-lingual publishing solutions can be integrated into your organization, be sure to contact the EAC Product Development team from the links below.

Learn More

Be sure to read Part One of this post to learn more about the solutions being deployed in the workflow being described.