What is EYH?

EYH is an event for middle school girls designed to nurture their interests in mathematics, science, and technology. Around 450 girls attend each year, and a typical day consists of four hands-on workshops in various STEM-related fields. DMC Houston engineers, including Elizabeth, Maddie and I, put together coding demonstrations to get them interested in programming.

Fun Processing Demos

After a quick ten-minute introduction to DMC and our backgrounds, the girls got to begin coding with a programming language called Processing. Processing is an open-source graphical library, which makes it a great tool for teaching the fundamentals of computer programming.

The first demo consisted of programming the proper sequence for a stoplight. The girls were given a template project that provided them with three functions: TurnOn, TurnOff, and Wait. They then had to use the functions in the proper order and with the correct arguments to simulate a stoplight. When done correctly, the program would run as demonstrated in the video below.

The second demo utilized x-y coordinate systems to draw a house. The girls were given a template project that contained a partially completed house. It was up to them to draw the remaining pieces with the proper coordinates. The last step was to color in the image using RGB values.

Take-Home USBs

After each session was over, the girls got to take home a USB that contained their stoplight project, their house project, and the Processing software. The goal was to encourage them to continue developing their programming capabilities outside of the EYH workshop.

Overall, the conference was a great experience, and hopefully, the girls enjoyed it as much as we did. As a company with a strong female presence, DMC is happy to foster young women and encourage them to pursue careers in STEM.

Learn more about DMC’s company culture. 

The post Young Women Learn to Code with DMC appeared first on DMC, Inc..

This video was inspired by having several simultaneous SCADA projects in the Houston office that nearly everyone on the team was involved on. We wanted a video focusing on SCADA, so the brilliant Peter King wrote parody lyrics to Avril Lavigne's "Sk8er Boi."

Being the newest Houston team members at the time, John Michael Frullo and I starred in the video. It was a fun way to bond with my new colleagues!

Learn more about DMC's company culture.

The post DMC Houston Releases “SCADA Boi” Music Video appeared first on DMC, Inc..

This library has the capability to simultaneously flash up to eight ECUs on separate communication channels. Additionally, these APIs are compatible with several application environments, including LabVIEW.

Learn vFlashStation API Calls

This blog explains how we were able to integrate Vector’s vFlashStation API with NI’s LabVIEW development environment to flash software to multiple ECUs at a time.

To flash an ECU, there are five necessary commands:

1. Initialize()
   
   Description: Synchronously initializes the vFlash library. This must be called before calling any other command.
    
2. Load Project(string Path, uint channelID, out long projectHandle)
   
   Description: Synchronously loads a packed project (.vflashpack) to a specific channel. The flash project contains important data such as the security seed key and necessary flashware. The packed project must be initially created using the vFlash GUI that comes with the hardware.
   
   Parameters:
    
   • Path: filepath to the vFlash packed project (.vflashpack).
      
   • channelID: Channel number for the project. It must match the numbers used in the Vector Hardware Configuration screen (vFlash CAN 1, vFlash CAN 2, etc.).
      
   • projectHandle: The method will return a handle (ID) for the newly loaded project.
      
3. Start(long projectHandle, CallbackProgressDelegate progressCallback, CallbackStatusDelegate statusCallback)
   
   Description: Asynchronously starts the flash process for the channel as indicated by the projectHandle.
    

   Parameters:

   • projectHandle: Handle (ID) to the project to be flashed. Should have been created during the Load Project method.
      
   • progressCallback: Delegate reporting the flash progress in percent and time remaining (seconds).
      
   • statusCallback: Delegate reporting the status of the flash process (enum containing success or error information).
      
4. Unload Project(long projectHandle)
   
   Description: Synchronously unloads the project associated with the project handle.
   
   Parameters:
    
   • projectHandle: ID of the associated project and channel. Should have been created during the Load Project method.
      
5. Deinitialize()
   
   Description: Deinitializes the vFlash library in order to free allocated resources.

These are the bare bone methods required to flash an ECU through the vFlashStation API. While the other methods are not described in detail in this blog post, Vector also created other API calls to customize reporting, networks, flash attributes, and custom actions.

Create a C-Based Wrapper of vFlashStation API

It’s important to note that the Start API method requires two callback delegates in order to correctly query the flashing status information. This is especially important for simultaneously flashing multiple ECUs. However, LabVIEW does not currently have a way to natively access or call a callback delegate.

The best workaround for this is to create a C-based wrapper to handle the callback delegate. In my case, I created a script using Visual Studio that referenced the vFlashStationAutomation DLL and housed my desired methods and callback delegates. The code snippet below shows how the vFlashStation API and callback delegates are utilized in my wrapper.
 

        public VFlashStationResult StartFlash()
        {
            VFlashStationResult startResult = VFlashStationAPI.Start(ProjectHandle, ProgressCallback, StatusCallback);
            return startResult;
        }


        /// <summary>
        /// The StatusCallback handles changes of the reprogramming status.
        /// If the reprogramming process was successfully finished, the callback contains
        /// the result <see cref="VFlashStationStatus.Success"/>.
        /// Otherwise the <paramref name="flashStationStatus"/> contains the error code.
        /// </summary>
        /// <param name="ProjectHandle">The project handle.</param>
        /// <param name="flashStationStatus">The flash station status.</param>
        /// <remarks>If detailed error information is required, 
        /// check <see cref="VFlashStationAPI.GetLastErrorMessage"/>.</remarks>
        private void StatusCallback(long ProjectHandle, VFlashStationStatus flashStationStatus)
        {
            Status = flashStationStatus;
        }

        /// <summary>
        /// The ProgressCallback contains progress information about the current
        /// reprogramming process containing the progress in percent and the
        /// estimated remaining time in seconds to finished the flash process.
        /// </summary>
        /// <param name="ProjectHandle">The project handle.</param>
        /// <param name="progressInPercent">The progress in percent.</param>
        /// <param name="remainingTimeInSeconds">The remaining time in seconds.</param>
        private void ProgressCallback(long ProjectHandle, uint progressInPercent, uint remainingTimeInSeconds)
        {
            PercentProgress = progressInPercent;
            TimeRemaining = remainingTimeInSeconds;
        }

        public VFlashStationResult StartFlash()
        {
            VFlashStationResult startResult = VFlashStationAPI.Start(ProjectHandle, ProgressCallback, StatusCallback);
            return startResult;
        }


        /// <summary>
        /// The StatusCallback handles changes of the reprogramming status.
        /// If the reprogramming process was successfully finished, the callback contains
        /// the result <see cref="VFlashStationStatus.Success"/>.
        /// Otherwise the <paramref name="flashStationStatus"/> contains the error code.
        /// </summary>
        /// <param name="ProjectHandle">The project handle.</param>
        /// <param name="flashStationStatus">The flash station status.</param>
        /// <remarks>If detailed error information is required, 
        /// check <see cref="VFlashStationAPI.GetLastErrorMessage"/>.</remarks>
        private void StatusCallback(long ProjectHandle, VFlashStationStatus flashStationStatus)
        {
            Status = flashStationStatus;
        }

        /// <summary>
        /// The ProgressCallback contains progress information about the current
        /// reprogramming process containing the progress in percent and the
        /// estimated remaining time in seconds to finished the flash process.
        /// </summary>
        /// <param name="ProjectHandle">The project handle.</param>
        /// <param name="progressInPercent">The progress in percent.</param>
        /// <param name="remainingTimeInSeconds">The remaining time in seconds.</param>
        private void ProgressCallback(long ProjectHandle, uint progressInPercent, uint remainingTimeInSeconds)
        {
            PercentProgress = progressInPercent;
            TimeRemaining = remainingTimeInSeconds;
        }

While not shown in this code snippet, I also kept each of the vFlash API calls exposed as individual public methods in my script (like the StartFlash example above). This made my application a little more flexible from the LabVIEW perspective since I could perform the tasks independently in any sequence.

Additionally, I also created a class called ECU in my C# script. This gave me a great way to group the information for each of my channels and neatly dispose of them when I no longer needed them. Each class stores the data that I need such as project path, project handle, channel ID, status, etc.

public class ECU : IDisposable
    {
        public string ECUname { get; private set; }
        public string ProjectPath { get; private set; }
        public long ProjectHandle { get; set; }
        public uint ChannelID { get; private set; }
        public uint PercentProgress { get; private set; }
        public uint TimeRemaining { get; private set; }
        public VFlashStationStatus Status { get; private set; }
        public VFlashStationResult Result { get; private set; }

        /// <summary>
        /// Generate class for each ECU. We get name, project path, and channel ID from LabVIEW
        /// </summary>
        /// <param name="projectHandle"></param>
        public ECU(string Name, string projectPath, uint channelID)
        {
            ECUname = Name;
            ProjectPath = projectPath;
            ChannelID = channelID;
            TimeRemaining = 0;
            PercentProgress = 0;
        }

public class ECU : IDisposable
    {
        public string ECUname { get; private set; }
        public string ProjectPath { get; private set; }
        public long ProjectHandle { get; set; }
        public uint ChannelID { get; private set; }
        public uint PercentProgress { get; private set; }
        public uint TimeRemaining { get; private set; }
        public VFlashStationStatus Status { get; private set; }
        public VFlashStationResult Result { get; private set; }

        /// <summary>
        /// Generate class for each ECU. We get name, project path, and channel ID from LabVIEW
        /// </summary>
        /// <param name="projectHandle"></param>
        public ECU(string Name, string projectPath, uint channelID)
        {
            ECUname = Name;
            ProjectPath = projectPath;
            ChannelID = channelID;
            TimeRemaining = 0;
            PercentProgress = 0;
        }

I then compiled the script to create my own DLL, titled StartFlash.dll. Integrating my wrapper into LabVIEW was simpler since I did not need to worry about the callback delegates.

Call DLL Methods from LabVIEW

There are two ways to call functions wrapped within a DLL: a Call Library Function Node, or an Invoke Node. A Call Library Function is useful when the DLL is a C/C++ DLL, and an Invoke Node is great for C#/.NET assemblies. You can also view NI’s knowledge article, Calling a DLL from LabVIEW, for more details.

In this case, we’ve created a .NET assembly so the correct option is to use the invoke nodes from the .NET palette within LabVIEW.

1. Place a .NET Constructor Node on the block diagram to instantiate a class within the .NET assembly.
   

   

2. Select the constructor by browsing for the desired .NET assembly DLL. For this example, we need the StartFlash DLL I created earlier and my ECU class.
   
   You should now have a constructor node with any required inputs (Name, project path, and channel ID). Wiring controls/constants to these inputs will initialize your class data.
    
   The output of this constructor node is a reference to the newly created class. This reference can now be wired into property nodes or invoke nodes in order to read/write class data or access public methods, respectively.
    

   

   

3. Wire the class reference to the input of an invoke node. You should see it automatically adapt to the reference type wired in.

     
    

   The available methods will automatically be populated based on the class reference. Select the desired method from the method drop-down menu and any inputs/outputs will automatically be created.
    

   That’s how simple it is to access public methods within a DLL. The only thing remaining is to organize the LabVIEW application to call the vFlash methods in the proper order in order to flash up to eight ECUs at a time.
    

   

   One last piece of advice: It’s always important to properly dispose of any references open in LabVIEW. In this case, we need to dispose of our .NET class and our .NET class reference.
    

   

Learn more about DMC’s LabVIEW programming experience.

The post Simultaneously Flash 8 ECUs with LabVIEW and Vector appeared first on DMC, Inc..

Aside from making a very addicting mobile phone application, AR is now being considered in industrial settings. It can be used to diagnose and troubleshoot machinery, or provide visual instructions for assembly or disassembly. For example, this video shows an AR program walking the user through the steps of changing a circular saw blade. This particular program was created with the Vuforia Studio Pilot Program.

Vuforia Studio Pilot Program

The Vuforia Studio Pilot Program integrates 3 distinct platforms: ThingWorx, Vuforia, and PTC Creo Illustrate. ThingWorx is crucial for transmitting data between devices, such as sensor data collected from a Raspberry Pi to a phone. PTC Creo Illustrate is a technical illustration software that allows you to create 3D sequences and animations with CAD data. Vuforia can then import data from ThingWorx and integrate it with the 3D models and animations from PTC Creo Illustrate to create an AR environment. With these three platforms, the Vuforia Studio Pilot Program is capable of creating some really cool AR experiences.

I created an AR experience for the 2016 AWC BestFest with the Vuforia Studio Pilot Program. If you’re interested in using the techniques mentioned in this post to create your very own AR experience, sign up for the Vuforia Studio Pilot Program. You’ll then get a service URL that contains your ThingWorx and Vuforia instance.

2016 AWC BestFest Beer Tank Demo

The 2016 AWC BestFest is a technology tradeshow held at Saint Arnold’s brewery in Houston, Texas. The festival is an opportunity for technology partners to mingle, show off new technologies, and drink beer. Another DMC employee gave a seminar on “Smart Manufacturing” and how IoT platforms can improve the industrial process. We decided some AR demos with IoT platforms would help illustrate this point. Being at Saint Arnold’s Brewery, I though it was fitting to have a demo centered around a beer tank.

For the demo, the user scans a specific “ThingMark” with their smartphone. These ThingMarks are essentially QR codes that are tied to unique augmented reality experiences. When you sign up for the pilot program, you get 100 different ThingMarks for your projects. 

Upon scanning the ThingMark, a 3D CAD model of a beer tank appears on the screen alongside with temperature and tank level values. The temperature and tank level values were simulated through a python script on a Raspberry Pi. Additionally, I created a step-by-step visual sequence that showed the user how to open the lid at the top of the tank. 

The following sections give a brief overview of how I accomplished it.   

Setting Up ThingWorks 

ThingWorx Foundation is an Internet of Things (IoT) platform that strives to create a “smart, and connected world”. What does this mean exactly? In this smart world, any and all electronic devices would be able to communicate with each other and execute services. For example, your printer would order its own ink cartridges after detecting low ink levels instead of relying on you. Or, your alarm would adjust when it woke you up depending on whether the train was early or late (look at this DMC blog for a similar project on how to track CTA Buses with a Raspberry Pi). Learn more about how DMC can help you with your IoT projects.  

Creating ThingShapes, ThingTemplates, and Things

ThingWorx is an object-oriented platform centered around “Things”. There are Things, Thing Templates, and Thing Shapes. Thing Shapes are the lowest level, and this is where you define properties, services, events, and subscriptions. So I created two Thing Shapes: TankTempShape, and TankFillShape. Here is where I first defined the temperature, fill level, name, and other properties I wanted to keep track of. I then created a Thing Template called TankTemplate that inherits from my two Thing Shapes. Finally, I created TankThing that inherits from my TankTemplate. The advantage to this object-oriented structure is that I do not have to redefine properties for each Thing I want to set up. If I had multiple beer tanks I wanted to track, then I could easily create several TankThing’s and each one would inherit from TankTemplate and already have the proper configurations. Alternatively, you could define all your properties and configurations within your Thing and it would work fine, but you would not be able to easily scale up your model. Once I created my TankThing, I had to ensure that I could receive data from my Raspberry Pi by setting up an application key.

Creating an Application Key

Each time you access your ThingWorx instance, you must login with your user credentials. So when you make an HTTP request with the Raspberry Pi, you’ll need to send along the username and password before you can alter the ThingWorx data. Alternatively, you can create an application key within ThingWorx for the specified user. Now when we make the HTTP request you can pass along the application key ID instead. Under the home tab, under security, there is a section for application keys. If there isn’t one already created, create a new one for the user you want to use (I used Administrator). Make sure your user has the proper read and write access. When you save it, it should generate an application key ID. Save this ID, you will need it in the next section.

Raspberry Pi Data Simulation

While I chose to simulate data within a python script, you can collect data from a sensor and export that to ThingWorx instead. In order to do that, you’ll need to utilize the GPIO library. You can use this reference to set up your inputs to collect sensor data. While I’m not going to go over my simulation code (wouldn’t really help you unless you wanted to run through the exact same numbers as me), I’m going to show you how to set up the HTTP request.

Making an HTTP Request to Edit ThingWorx

In order to do this, you will need to import the JSON and Requests library. The Requests library is an awesome tool that makes HTTP requests really simple. Everything you need can be condensed into one line of code.

If you don’t have the Requests library already installed, enter the following lines into the terminal to get them.

1.  sudo git clone git://github.com/kennethreitz/requests.git  
2.  cd requests (i.e. change directory into the folder that git has just added)
3.  sudo python setup.py install

Now you’re ready for the HTTP request. The following lines of code only work for my specific ThingWorx and Vuforia instance. You’ll need to replace the URL with your service URL, replace the blacked out portion with the application key ID from your ThingWorx, and replace TankThing with the name of your Thing. That will ensure that the Raspberry Pi is sending the data to the correct location.

Lastly, you’ll need to edit the payload line with your own custom variables. The blue text corresponds to the properties within ThingWorx, and the black text corresponds to the variables within the python script.

Afterwards, save your python script and execute it from the terminal. You can test the script by going into ThingWorx and checking your Thing’s properties. Hit the blue refresh button next to Values to see the values change. If it’s not updating, check to make sure the URL, Thing name, application key, and payload terms are correctly typed. Also check that your python script is properly collecting/simulating values.

PTC Creo Illustrate

Import an Existing CAD Model

PTC Creo Illustrate is a great program for creating animations and visuals, however, you can’t create CAD models. You can use other programs such as PTC Creo Parametric, PTC Creo Elements, SolidWorks, or AutoCAD to create your own model. Alternatively, you can download a file from GrabCAD or other free sites. Once you’re ready to import, go to File -> Import and then select your CAD file. When you click Open you should get a window similar to the one below.

Now you can make edits to your model like rotating or translating your device, creating sections, sequences, and animations. For my particular demo, I created a sequence  that shows how to open the lid at the top of the beer tank.

Creating a Sequence

You can create a sequence to showcase anything from assembly, disassembly, movement, or internal components. Once you have your figure imported, click on the “Sequence” tab at the top of the window. You’ll now see a slew of visual manipulation options.

Click “Add Step” to begin the process. You can now add whatever motions you desire. There are several effects that you can add to individual pieces such as fly in/out, fade in/out, shake, pulse, unscrew, etc. Play around with them to determine what you want. You can add several effects to one step and PTC Creo will do its best to combine them all into one fluid motion. If you want them to be separated, make sure to put them in different steps. Continue to add steps, translations, and effects until you have the desired sequence. You can then go to “Preview Sequence” to view your entire sequence.

Publishing Your File

Once you’re happy with your sequence, you’ll need to publish your program in order to get two files: .pvz file, and .pvi file. The .pvz file is your 3D model, whereas the .pvi file stores your animation information. 

1. Go to File -> Publish. 
2. Publish it as a new .pvz file.
3. Go to your new file and RENAME it as a zip file (do not send to a zip file, for some reason this does not seem to work).
4. Extract all files

After extraction, you should be able to see a .pvz file and a .pvi file in your new folder. These files will be imported into Vuforia Studio.

Vuforia Studio

Here is where all the augmented reality magic happens. Here you’ll set up your 3D models, 2D and 3D widgets, ThingMark, and import ThingWorx data.   

Importing Your 3D Model and Animation

In order to use your 3D model and animations, you’ll need to import your files into Vuforia.

1. On the left under Resources, click the blue plus sign.
2. Click Select File and find your .pvz file and click ADD.
3. Repeat for the .pvi file.
4. Close out of that window. 
5. Drag a 3D Model into your environment.
6. To the right under the “Properties” column, go to “Resource” and select your .pvz file.
7. Under “Sequence URL”, select your .pvi file.

Configuring a Button to Control Your Sequence

Now we have a 3D model and sequence imported into Vuforia, but nothing is currently telling it to run. To fix this, I configured toggle buttons that appear on the smartphone screen that execute play/rewind/forward actions.

1. Select 2D view under Canvas.
2. Drag a Toggle Button onto any of the panels (your choice).
3. Under your Toggle Button properties, drag the blue cross icon next to “Click” all the way to the left to your 3D model icon under “Views”.
4. A new window will appear where you can select what action that button will have. Selecting “Play” will cause the next step in the sequence to play.

Add as many buttons as desired. As shown in the images of the 2016 BestFest demo, I had four distinct buttons: play, play all, rewind, and forward. You can also change what your buttons look like by changing “Image When Pressed” and “Image When Not Pressed” under Properties. You can import your own button images following the procedure for importing the CAD model. Play around with the Toggle Button’s properties to your heart’s content.

Importing Data from ThingWorx

There are several widgets available for displaying values. You can use 3D labels and gauges, or 2D gauges and value displays. Once you’ve selected your widget, you’ll need to connect the value to the ThingWorx Data. On the right-hand side, there is a tab called “External Data”. Click on the plus sign and you’ll be taken to a search engine as shown below.

1. Use the top left search engine to find your Thing by its name.
2. Click the blue right arrow. 
3. In “Filter Services”, type “GetPropertyValues” and click the blue plus symbol when it pops up.  It should now be added to “External Data”.
4. Close out of the search window.
5. Expand “External Data”. 
6. Expand “Configurations”.
7. Select “Invoke on Startup”, and “Auto-Refresh”.
8. Change the Auto-Refresh rate to something that fits your project (I used 1 second).
9. Go to “Current Selected Item” to get a list of all your available properties. 
10. Drag the blue cross icon from the desired property over to the blue circle beside “Value” on your 2D/3D widget. 

This will cause the widget to show the value of the property from the ThingWorx Foundation platform. Repeat the last two steps for all of your widgets. 

Publish Your Experience

In order to save and publish your experience, you’ll need to associate a ThingMark to your experience.   

1. Under 3D view, drag a ThingMark widget (under “Views” in the left hand column) into your environment.
2. Under “Application Parameters”, drag the blue cross icon next to ThingMark to the blue circle next to ThingMark under the Properties  column for your ThingMark widget. 
3. Change the number to match the number of the ThingMark you’ll be using for the experience (it’ll be the name of the file in your ThingMark folder given to you with the pilot program).
4. Adjust the ThingMark widget’s location in your 3D canvas so that it is in the same manner it will be placed in real life.

Now go to “Experience” under Configurations. Give your experience a name in the “Title” box and retype your ThingMark number from before.

Now that everything is set up, it’s time to save your experience and publish it. Click on “Save” in the top left corner, then click on “Publish”. Once it has successfully published, your AR experience is ready to be viewed on a smartphone or tablet with the Vuforia View Enterprise application downloaded.

Vuforia View Enterprise 

Almost finished! The last step is to download Vuforia View Enterprise onto your smartphone or tablet. Once you have it downloaded, open up the application, go to settings, and type your service URL. Now print the ThingMark that you used in Vuforia Studio and scan it with your smartphone or tablet. Open up your experience and enjoy your new augmented reality!        

Learn more about DMC’s Custom Hardware and Software development.

The post Creating an Augmented Reality (AR) Demo with the Vuforia Studio Pilot Program appeared first on DMC, Inc..