• optimizing performance with smart connected products
• minimizing downtime with predictive analytics
• provide access to accurate and relevant documentation, illustrations, and part lists
• improving service response time and first-time fix rates
• optimizing service parts availability and pricing
• paying for product performance with product-as-a-service (PaaS) models

Augmented Reality (AR) uses devices such as smart glasses and phone applications to overlay digital information on the real world. The resulting experiences provide a convergence of digital and physical worlds. Isn’t this what we’ve all been waiting for? For technology to catch up with us? How did we end up here? Where did it all begin?

If you think back to your earliest introduction to Augmented Reality, what do you think of? I tend to think back to Star Trek’s holodecks – augmented facilities that characters used for recreation and for work. But the idea of bringing together virtual and physical worlds has been around for longer than you think.

The first traces of an Augmented Reality device originated in the late 1960’s by computer scientist, Ivan Sutherland, at Harvard University when he was working on what he called “the ultimate display.” The device, called the Sword of Damocles, displayed a geometric grid of graphics over the user’s view of the room. The component parts to the device were so large and heavy that it had to be mounted from the ceiling and suspended with a mechanical arm that supported the head mounted display (HMD). It wouldn’t be until many years later that AR would be introduced to mainstream media as a device that could be used in the manufacturing world.

Not unlike Steve Jobs’ idea that the individual consumer may want his or her own personal computer – working designers and engineers are implementing the individual use of AR to improve workforce efficiencies. Why might manufacturers want Augmented Reality in their hands and in the workplace? What are the benefits?

Augmented Reality helps you work a lot faster.

For Designers and Engineers, a lot of time spent on the manufacturing floor is working with the design in one work space and moving to another space to test the product. With the aid of hands-free AR devices, you’ll be spending a lot less time writing down changes. You’ll be able to make a virtual change to a design with the swipe of a finger or by the nod of your head. You will no longer have messy notepads filled with your ingenious ideas with room for error, missing notepads, or frustration with file-keeping. Your AR glasses will be able to keep up with your fast-paced mind and you’ll be redirecting your energy towards developing new products and improving existing ones.

You can use AR to provide hands-on learning for employees.

Have you ever sat in class writing or typing down all the notes you could possibly think of to ensure that you would apply those rules later while you’re in the field? I know I have. How many times have you actually looked back at those notes? Augmented Reality in the workplace gives employees an opportunity to thrive in their learning environments. Hands-on learning can result in up to a 75% retention rate. AR devices produce real-time images of physical objects with virtual work instructions that guide you while you’re on the manufacturing floor. So yes, traditional training will still be relevant – but you’ll be able to supplement your learning with hands-on experience too.

Vuforia Studio allows you to access data easily.

Vuforia Studio, a PTC Service Lifecycle Management (SLM) tool, is used to improve service, operation, engineering, and manufacturing with AR capabilities. This app is a powerful solution for creating, deploying, and consuming AR experiences within your enterprise. Vuforia Studio has an easy-to-use ‘drag and drop’ interface so that users can quickly create and share scalable AR experiences.

Augmented Reality helps to refine and optimize design in early stages of product development. Smartphones, tablets, and smart glasses can retrieve product data such as sensor readings, locations, temperatures, sales history, warranty history, and other service information. Concepts, modifications, and new ideas can be reviewed and changed quickly. 3D parts observed using a wearable augmented reality device will give designers and engineers a better visualization of a finished product. What’s the result? Rapid repetitious design cycles and the optimization of product design and development.

Solve business problems and provide competitive differentiation with Vuforia Studio – download the product brief.

If you’re interested in talking to us today about Vuforia Studio, then email us at communications@eacpds.com or call us at 1-888-225-7579.

Here’s why engineering processes affect services and why streamlining information could solve the whole problem. 

The Problem: Lack of Communication

Let’s be honest, engineering and manufacturing departments do not always communicate product changes to service. This is just the start of how your engineering processes affect services. 

The Result: High Costs

When technicians reference outdated product information and arrive with incorrect parts, this leads to longer service visits, extraneous costs, longer downtime, and lowered customer satisfaction.

The Solution: Streamlining Information

Streamline the way you service teams access and use product information. The best way to accomplish this involves accurately transforming eBOMs (engineering bill of materials) to sBOMs (service bill of materials) and maintaining the fidelity of that information after engineering changes.

It’s time to stop letting your engineering processes affect services.

Take full advantage of the product data your organization has already created.

Structure service manuals and part information based on how a specific product is configured and serviced. Reuse engineering and manufacturing data in the service environment. Provide configuration-specific information to service technicians. Create a single point of access for your service content. Avoid text – use and repurpose graphics, animations, and CAD information when possible. And link service information to engineering information so changes propagate.

Next: Identify Your Service Needs 

Identify what should go in your sBOM to ensure your sBOMs meet the needs of the service department. Examples might include what is serviceable versus what is replaceable, the status of a part, the components, models, grouped items, and more.

The Goal: Transforming Your Services

Remember: the ultimate goal is to make your customers happy. As a result of combining best practices with the right technology to support service and parts information management and publication you will see a higher customer satisfaction, improved technician effectiveness, improved brand reputation, higher profitability (due to lower revenue and service cost), time savings, and higher revenue (from repeat business and customer loyalty).

We have a team of technical communications specialists that would love to talk with you about your current state and current initiatives…

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.

PTC’s Service Information Manager adds three advanced capabilities to the XML authoring and content management system:

1. Translation Management
2. Part List Generation
3. Publication Structures

My last blog focused on Publication Structures. You can read more about publication structures here: Revolutionizing Book Assembly with SIM. Next time I will discuss Translation Management. However, today I’m discussing Part List Generation, how to create value from part data.

The Engineering Bill of Material (BoM) is structured based on the design. The Service BoM is then derived from the Engineering BoM. With the part structure defined, you can visually identify parts and add them to various service kits and assemblies and ultimately generate a part list from the structure that can be used in technical publications. Updates from source parts and drawings to downstream processes are practically automatic. Building part lists with associative, up-to-date service information increases the accuracy of information and improves authoring efficiency thereby reducing time to market.

Each component in a drawing can be a part with its own lifecycle that is managed and repurposed in an integrated system. All too often we see disparate systems with Engineering drawings in one system and part data management in another.

Many users of Windchill use it as a CAD warehouse to store content more or less. Sure users of the design engineering tools find them extremely valuable, many folks are leveraging workflow processes and lifecycle features to expedite the day-to-day flow of information, and many have found that the change management tools add value when it comes to maintaining change integrity and traceability. Nonetheless, many organizations are not leveraging their parametric data for parts management (you know who you are).

The ability to repurpose Engineering design part structures to create Part Lists for Service information is the promise land. But the system can only repurpose parts if they exist as parts in the system. Generating part lists for catalogs and online delivery requires parts with end items and part structures. So in other words, using Windchill Service Parts and Service Information Manager requires part data  management in Windchill PDMLink.

Service parts management provides an out-of-the-box method of generating Part Lists for the technical documentation community from a single source of information. As a result, organizations are able to greatly improve the process of information delivery and are able to leverage dynamic publishing capabilities to bring products to market faster, and keep customers better informed.

Learn More

Refer to PTC’s web site for a complete description of Service Information Manager.

EAC information solution experts have decades of reliable XML solution experience. Explore the EAC website to learn more about our products and services or review the Product Development Information Services Brochure.

Many PTC Creo users may be surprised to discover that hidden in their Creo file directory, there are two powerful CAD automation tools just waiting to be utilized! Creo Web.Link and Creo J-Link are two API tools that are packaged with all Creo installs; no extra licensing necessary. Both tools provide a way to access and modify your CAD data from a custom User Interface (UI) or a webpage.

The question is, what benefits can you reap from these tools? Perhaps there are technical staff members that don’t know the Creo tool, but they want to generate drawing PDF’s by entering some dimensional and parameter information. Conceivably, customer orders could be retrieved from a database to drive CAD or generate a Point of Departure (PoD). There are many opportunities that may arise where a UI is more efficient than modifying your CAD data directly in Creo. Today, we’ll focus on Web.Link due to its relative simplicity compared to J-Link.

Web.Link utilizes Creo’s embedded browser to reach into your CAD session and touch almost every aspect of a model, assembly, or drawing. A user builds a webpage and connects to the CAD using the JavaScript API. One caveat of Web.Link is that a user MUST use the embedded browser, whereas with J-Link, the program you create can run asynchronously – meaning Creo does not have to be running to use it.

The full functionality of Web.Link is documented in your Creo install directory at ‘[datecode]Common Filesweblinkweblinkug.pdf.’ There is also a searchable API located in the same directory which provides more detailed information on all the available features. The documentation may be a bit overwhelming at first, but here are the basic steps.

Basic Steps of Getting Started with Creo Web.Link

1. Create a web page with text input, buttons, and anything else that you may use to access or modify your CAD. For example, you may have some dimensions or parameters you may want to modify. You may want to run a macro (mapkey). Or, you may just want to display relevant model information.

   

2. Use the JavaScript objects, classes, methods, etc. to connect everything to CAD.

   

3.  Open the webpage in your Creo embedded browser and try it out! There are prepackaged examples for you to try in the Web.Link directory if you don’t want to jump in the deep end right away. There is also a ‘pfcUtils.js’ file that comes in handy for many of the Web.Link programs you’ll write. It’s a library of useful pre-built functions that many of the examples use.

   

A couple of Items to Note:

1. Be sure to read the section in the Web.Link User Guide that addresses browser security. Running javascript in an Internet Explorer (IE) browser session typically sets off red flags and you’ll have to configure your IE security to enable the ActiveX scripts. Alternatively, you can use the Mozilla browser, and use a few lines of code in your JavaScript (See Figure 2) to address it.
2. There are a few configuration options that must be enabled to allow Creo Web.Link to access the CAD session. The relevant configuration options are:
   • WEB_ENABLE_JAVASCRIPT
   • WEB_LINK_FILE_READ
   • WEB_LINK_FILE_WRITE
   • WEB_LINK_PROE_READ
   • WEB_LINK_PROE_WRITE

Creo Web.Link is a simple tool that can make a huge difference in how your company interacts with its CAD data. I encourage you to skim through the Web.Link User Guide and try out some of the examples provided. If you have any questions about Web.Link, please direct them to the comment section. If you have any questions related to CAD Automation services provided by EAC, please contact us! If you need an extra copy of the PTC Creo Web.Link User Guide, click the image below to download.