• Part 1: Creating and Opening a Project
• Part 2: Folder Structure and Gedi Layout
• Part 3: Panels | The Basics
• Part 4: Panel Scripting Environments and QuickTest
• Part 5: Scripting Syntax
• Part 6: Para Overview and Datapoint Creation
• Part 7: Interacting with Datapoints via Scripting
• Part 8: Libraries
• Part 9: Color Database & High-Performance Best Practices
• Part 10: Panels | Panel Nesting and $-Parameters
• Part 11: Panels | Child Panels (Popups)

What is a Module?

As noted in Part 11 of “Getting Started with WinCC OA”:

“Modules represent their own program window, meaning that the child panel is disjointed from the calling panel and its respective calling module. If the calling panel is changed/closed, the child panel/module will remain opened.”

Modules can be hidden, minimized, maximized, zoomed, and much more. While these topics aren’t pertinent to get started with WinCC OA, they’re still helpful to note. With that said, we’ll now focus on embedded modules and their applications.

Embedded Modules

Like child panels, embedded modules are used to display sub-panels in conjunction with a main panel. On the contrary, while a child panel opens in front of the calling panel, an embedded module exists within an allocated space on the main panel itself.

These embedded modules are helpful for presenting dashboards, portioning out screen real estate, displaying alarm buffers, and more.

For example, one of the default templates located in the base project (Panels/para/PanelTopology/templates/TEMPLATE3/basePanel_1024_768) uses embedded modules to divide the screen into three functional areas. The template contains three primary embedded modules with names that dictate their general purposes:

While we won’t go into too much detail on templates here, it’s important to note that when implemented during runtime, the embedded modules allocate a certain quantity of real estate and present certain sub-panels on the overall display.

• mainModule: Displays the general user-defined screens
• naviModule: Displays the UI’s navigation controls
• infoModule: Displays pertinent information (alarms buffer, date/time, user, etc.)

During runtime, the naviModule and infoModule continuously display their respective content while the mainModule displays the main panels, as defined in the project’s Panel Topology (Panel Topology will be discussed in a later blog installment).

Embedded Module Functions

The most relevant embedded module functions are as follows:

• RootPanelOnModule()
  • Opens a panel in a specified module.
  • Arguments include:
    • FileName – File within the “panels” folder to open.
    • PanelName – Name given to panel.
    • ModuleName
      • Name of module in which the panel will open.
    • Parameters
      • Panel $-Parameters; see Part 10 for information on $-Parameters and Part 11 for how to pass them into panels from calling functions.
• PanelOffModule()
  • Closes the panel in a specified module.
  • Arguments include:
    • PanelName – Name of panel to close.
    • ModuleName – Name of module in which the specified panel is open.
• rootPanel()
  • Returns the name of the panel open in the given module.
  • Arguments include:
    • ModuleName – Name of the root panel open in the specified module.

Fortunately, embedded modules are relatively straightforward to work with. One item to note, however, is that the argument “ModuleName” for relevant functions pertains to the “ModuleName” property (located under the “Extended” properties tab) rather than the embedded module object’s “Name” (located under the “Standard” properties tab).

In addition to its explicit string value, the “ModuleName” can be referenced in scripting using the notation:

<object name>.ModuleName

Example

We’ll continue working with our evolving example from prior blogs to create a dashboard using embedded modules.

Better Naming Practices

First, we’ll do a brief rename of our current panels/DPTs, since names like “TestPanel” and “ChildPanel” are not very descriptive. Please make the following panel changes:

• Rename: ChildPanel.pnl → SetSpeedLimitPopup.pnl
• Rename: TestPanel.pnl → MotorInfoPanel.pnl
• Delete: ParentPanel.pnl (it will not be needed anymore) 

Note: the “ChildPanel.pnl” string in the MotorInfoPanel’s “settingsButtonClicked()” function will need to be changed as well.

In addition, we’ll change the DPT name “myDatapointType” to “Motor” by right-clicking on the DPT in Para and selecting “Edit Datapoint Type.”

Dashboard

Create a new panel called “main.pnl.” This will represent a main/home screen on a SCADA system. Please adjust your panel dimensions according to your screen resolution:

At the top of the panel, we’ll add three objects with the following specified properties:

• A simple border for our “dashboard”:
  • Object: Rectangle
  • Name: “dashboardBackground”
• An embedded module frame for one of our dashboard items:
  • Object: Embedded module
  • Name: “motorInfoDashboard”
  • ModuleName: “motorInfoEmbeddedModule”
  • Size: Make identical to the “MotorInfoPanel.pnl” panel size
• An object to use in embedded module interaction:
  • Object: Button
  • Name: “nextMotorButton”
  • Button text: “Next Motor”

Within our panel’s scopeLib, we’ll have a few constants and variables defined.

Constants:

• MOTOR_INFO_PANEL = name of the motor info panel to open.
• DP_MOTOR_LIST = list of all DPs of type “Motor”.
• NUM_MOTORS = number of motor DPs.

Variables:

• _dpCurrentMotorInfo – panel-scoped variable keeps track of the currently displayed motor DP.

Functions:

• motorInfoDashboardInitialized() – called by the panel’s “Initialize” event; establishes the first motor displayed by calling “displayNextMorotInfoPanel()”.
• nextMotorButtonClicked() –  called by the “nextMotorButton” button’s “Ckicked” event; calls the “displayNextMotorInfoPanel()”.
• displayNextMotorInfoPanel() – Displays the next motor DP defined in the DP_MOTOR_LIST into the motor info panel.

// Display the next motor in the Motor Info Dashboard
displayNextMotorInfoPanel()
{
    // Only attempt to display a dashboard if motors exist
    if (NUM_MOTORS > 0)
    {
        // Determine the next motor in the motor list
        int iNextMotorIndex =
            (dynContains(DP_MOTOR_LIST, _dpCurrentMotorInfo) % NUM_MOTORS) + 1;

        _dpCurrentMotorInfo = DP_MOTOR_LIST[iNextMotorIndex];

        // Open the Motor Info panel for the selected motor
        RootPanelOnModule(
            MOTOR_INFO_PANEL,
            "MotorInfoPanel" + _dpCurrentMotorInfo,
            motorInfoDashboard.ModuleName,
            "$motorDpe:" + dpSubStr(_dpCurrentMotorInfo, DPSUB_DP)
        );
    }
}

// Display the next motor in the Motor Info Dashboard
displayNextMotorInfoPanel()
{
    // Only attempt to display a dashboard if motors exist
    if (NUM_MOTORS > 0)
    {
        // Determine the next motor in the motor list
        int iNextMotorIndex =
            (dynContains(DP_MOTOR_LIST, _dpCurrentMotorInfo) % NUM_MOTORS) + 1;

        _dpCurrentMotorInfo = DP_MOTOR_LIST[iNextMotorIndex];

        // Open the Motor Info panel for the selected motor
        RootPanelOnModule(
            MOTOR_INFO_PANEL,
            "MotorInfoPanel" + _dpCurrentMotorInfo,
            motorInfoDashboard.ModuleName,
            "$motorDpe:" + dpSubStr(_dpCurrentMotorInfo, DPSUB_DP)
        );
    }
}

When running the main.pnl panel in QuickTest, we can iterate through the relevant motor DPs by clicking the “Next Motor” button.

So far, we’ve worked with panels of static widths and heights; however, developers can adjust panel reference dimensions, and users can sometimes resize a given window. OA provides functionality to accommodate for the positioning of objects within a panel when the overall panel dimensions shift.

In the next edition of “Getting Started with WinCC OA,” we’ll take a brief look at panel layouts and how we can use them to dictate the real estate of a panel.

Topics to look forward to in this series: 

• Part 12: Modules & Embedded Modules

Contact DMC to get started on your next WinCC project and learn more about our Siemens SIMATIC WinCC Programmingas well as our WinCC Open Architecture Development.

The post Getting Started with WinCC OA: Part 12 – Modules and Embedded Modules appeared first on DMC, Inc..

Setup: WinCC OA Manual Generation

The first thing you need to do is create your assets in both the WinCC OA project and the MindSphere tenant. I’ll start with the WinCC OA project. Open Gedi in your project and from the top toolbar navigate to ‘SysMgm’ < ‘Settings’ < ‘MindSphere Configuration.’ This will open a window like the one shown below.

Within here you can manually instantiate datapoints for you MindSphere application. There are three levels of organization to your MindSphere data. At the highest level are assets, then within an asset, there are data sources, and within those data sources, there are datapoints.

What exactly defines an asset or data source within your project is up to you. For instance, an asset could represent one of several lines on a factory floor, and each data source could be a machine or PLC used within that line. It is up to you to decide how best to structure your data.

To create an asset, simply right click the whitespace in the column on the left and select ‘Create MindSphere Asset.’ You can right-click that asset to add a data source and right-click that data source to add datapoints. When creating assets and data sources, all you really configure is the name. When creating datapoints, you must also select a datatype and enter the units. Datatype selection is limited to ints, longs, double, Booleans, and floats, so be aware of this when creating your application. It is also crucial that you do not leave units blank.

To map your OA data point to a data point in an asset in MindSphere, the units on the two data points must match exactly. We’ll touch more on this later.

Setup: WinCC OA Scripted Generation

If you are working with a large volume of datapoints, then manually entering them all, as I showed above, can be impractical. Fortunately, there is a way to script the generation of these points. Whenever an asset, source, or point is created in the MindSphere Configuration menu, an internal datapoint is created in Para of the type _MC_Asset, _MC_Datapoint, or _MC_Datasource respectively.

What this means is that you can write a script that uses the dpCreate and dpSet functions to create your data structure and populate some necessary fields. You must be careful when doing this, though, to set up your data correctly. Make sure your asset’s DataSources is populated with the names of all associated data sources.

Do the same for making sure the data source has its associated points and assets entered and that the points have their associated data source. Don’t forget to set your points’ unit and type as well. Type is represented by an integer from 1 to 5, where each number equates to one of the datatypes mentioned earlier. Try first making a simple data structure as I did here and dig around the generated internal points, so you understand how it’s all supposed to be set up.

Setup: MindConnect Lib Asset

Next, we will create our MindConnect Lib asset. The MindConnect Lib assets are what your assets in OA are going to establish a connection with an upload data to. There is a one to one relation between MindConnect Lib assets in the tenant and assets in your OA project so you will need to make one MindConnect Lib asset for each asset in your OA project.

From your home page in MindSphere, go to the asset manager and select ‘Create asset.’ Select MindConnectLib and give your asset a name.

Next, we’ll set up our connection to the OA asset. Click the large button with the puzzle piece on it and select your preferred security profile.

I’ve used SHARED_SECRET for all of my applications. After hitting continue, you’ll be taken to another screen with the boarding configuration. Click the buttons to generate a boarding key and copy it to your clipboard.

Now go back to the OA MindSphere configuration menu, click on your asset, and paste the onboarding key into the white box then hit the upload button at the bottom.

Your assets in the OA project and tenant are now connected. You’ll notice that the Configuration ID has been filled in for your asset and all associated datapoints. Now, if you go back to your asset in the MindSphere tenant and click the button with the puzzle piece on it, you’ll be taken to a new screen.

Here you can see the configuration of your asset and its data mappings. The configuration shown should match exactly with what you set up in OA.

Setup: MindSphere Assets for Data Mapping

To actually work with and visualize the data that you’re sending to you MindConnect Lib asset, you need to create assets to map that data to. To do this, you will need to create some aspects and types. Both aspects and types are configurable data structures. A type will contain aspects, and you’ll create instances of types in the assets menu like how you create the MindConnect Lib asset.

Similar to the structure of the MindSphere configuration in the OA project, it’s up to you to decide how best to structure your data. To make an aspect, go to your tenant’s asset manager, select ‘Aspects’ from the menu on the left, and select ‘Create aspect.’ Add at least one variable to make a valid aspect and make sure to set a ‘Unit’ value that exactly matches the units you set up in OA for the data point you intend to map to it. You will not be allowed to map your data points if the units don’t match.

Similar to how you created an aspect, you will now create a type. Types are just another layer in the data hierarchy of MindSphere. Types can contain variables, aspects, and have an associated image for an organization. Additionally, an instance of a Type is an asset, whereas you cannot instantiate aspects as assets.

Add whatever aspects and variables seem sensible for your type, but be aware that you cannot map your OA data points to the standalone variables in a type. They must be mapped to a datapoint in an aspect in that particular type.

Now go back to assets and create an instance of the type you just created. Go to the Configuration/Data mappings page for your MindConnect Lib asset and go to the Data mappings tab. If you expand the data structure you should see a button that says ‘Link variable’ for each data point. Click on that and navigate to the appropriate data point in the instance of the custom type that you created.

Once mapped, it should look something like the above image. Something significant to note is that these datapoint mappings are somewhat fragile, and any changes made to your OA assets, like adding points or sources or changes units, will undo these mappings. For that reason, you should try to finalize your data structure as much as possible before going through the effort of mapping points.

Pushing Data to MindSphere

You have now made all the necessary arrangements and are ready to push that data up to MindSphere from your OA project. I’ve made a straightforward script that goes over all the essential actions that must be done to upload data.

#uses "classes/mindSphere/MindSphereAsset"

// Example script showing how to push data from OA to MindSphere

main()
{
    // Instantiate a MindSphere asset
    MindSphereAsset asset = MindSphereAsset("TestAsset");

    // Generate sample values
    dyn_int testValues = makeDynInt(
        13,
        67,
        89
    );

    // Create timestamps for the samples
    time currentTime = getCurrentTime();

    dyn_time times = makeDynTime(
        currentTime - 2,
        currentTime - 1,
        currentTime
    );

    // Prepare values for upload
    int err = asset.prepareValues(
        "TestPoint1",
        testValues,
        times
    );

    // Upload values to MindSphere
    err = asset.uploadPreparedValues();

    if (err == 0)
    {
        DebugN("Upload Successful!");
    }
}

#uses "classes/mindSphere/MindSphereAsset"

// Example script showing how to push data from OA to MindSphere

main()
{
    // Instantiate a MindSphere asset
    MindSphereAsset asset = MindSphereAsset("TestAsset");

    // Generate sample values
    dyn_int testValues = makeDynInt(
        13,
        67,
        89
    );

    // Create timestamps for the samples
    time currentTime = getCurrentTime();

    dyn_time times = makeDynTime(
        currentTime - 2,
        currentTime - 1,
        currentTime
    );

    // Prepare values for upload
    int err = asset.prepareValues(
        "TestPoint1",
        testValues,
        times
    );

    // Upload values to MindSphere
    err = asset.uploadPreparedValues();

    if (err == 0)
    {
        DebugN("Upload Successful!");
    }
}

Note the steps in the above script. You must first instantiate your asset within your script via the MindSphereAsset function. The string inputted here must be identical to the name of the asset you created earlier in the configuration menu.

Next, I make an array of sample data to upload. You can also upload points one at a time, but it will be more computationally intensive. For every bit of data that you create, you also need a timestamp. Here I take the current time then have offsets by one and two seconds. Before you upload your values, you must prepare the values for upload.

The first input here is the name of the datapoint you’re uploading to, and it must match exactly with the name of the intended datapoint. After you’ve prepared your values, call asset.uploadPreparedValues to upload all values that have been prepared for that asset since the last successful attempt to upload values. You can call asset.prepareValues as many times as is necessary before executing the upload, and uploading data in large batches rather than small chunks will be a lot faster computationally.

If the upload was successful, then the value of err, the output from the upload function, should be equal to zero.

Viewing Your Data in MindSphere

There’s a ton that you can do with your data once it’s in MindSphere, but that’s a whole different discussion, so here we are simply going to view the time series of our data. To view your data, go back to the home page of your MindSphere tenant and navigate to the Fleet Manager. Search for the instance of your custom Type that you created and click on it. The page should then show all the aspects associated with your type in the central window. Click on an aspect to see the time series of incoming data. To view data that cannot be graphed, like strings and Booleans, click on the checkerboard looking button in the bottom right corner under the graph.

As you can see in the figure below, there are two instances of the three values I sent with my simple script because I ran the script twice.

Final Tips

• Take time to plan out your data organization in advance.
  • The systems of aspects, types, and assets and points, sources, and assets can seem convoluted at first, but if you take the time to plan out your project, then these organizational layers can prove very useful.
• Be careful of breaking your tag mappings in MindSphere.
  • Remember that making any changes to your OA asset configuration will break all of your tag mappings, and you will have to delete and reestablish those mappings manually. This is another reason to have a good organization plan in mind before digging into things.
• One call to Upload 1000 datapoints is a lot faster than 1000 calls to upload one datapoint each.

Learn more about DMC’s WinCC OA services and our Siemens expertise. Contact us with any inquiries. 

The post How To Setup a WinCC OA Application to Push Data to MindSphere appeared first on DMC, Inc..

History

WinCC OA is provided to users as a clean sheet. It has incredibly powerful ways of creating reusable and self-configuring objects, but this is “an exercise left to the user,” as my old college professors would say. Rather than continually reinvent the wheel each project, we decided to distill best practices into a set of tools that integrate seamlessly into the Siemens PLC Open Library. This resulted in the alpha version of a WinCC OA Open library in July 2017.

This initial version was a great start for clarifying how to use the new WinCC OA Object-Oriented CTRL++ language that had just been released. Several revisions later, we have an extensible code base covering the key elements of the PLC Open Library and are ready to share it with the world.

Components

This latest version has implemented the critical portions of the PLC Open Library with objects for:

• Motor – Contactor
• Motor – VFD
• Pump – Contactor
• Pump – VFD
• Valve – Solenoid
• Valve – Analog
• System Control Object
• Interlock Object
• PID Compact Object

There are plenty of helper objects, such as the text indicator and entry objects not listed here that are used by the objects above. These can often be utilized by themselves as part of your project or embedded into your own custom objects!

Look and Feel

These objects have behavior and visualization that is similar to the PLC Open Library while still extending the functionality to provide for the benefits of using WinCC OA.

One of those extra benefits that WinCC OA provides is the ability to use color schemes. Color schemes are sets of named colors that can be swapped into place on a system during runtime. This ability allows for implementations like day/night mode.

In this case, we implemented the DMC Open Library standard color set and a High-Performance HMI color set. You can create your own color set and customize the color scheme to whatever works for your project.

Utilities

Tag creation in SCADA systems can be a daunting task. This task is especially true when you have smart objects with a rich tag structure like the PLC Open Library.

As a result, we needed to create a better way to manage tag generation for the Open Library. The included tool allows a DB export from a Siemens PLC to be converted to an import file for WinCC OA. With the included capability to handle descriptions, units, formatting, and naming, the work of days can be reduced to minutes with this tool!

Conclusion

WinCC OA is a very powerful platform that gives the user a level of flexibility and capability not seen in other platforms. This power comes at the cost of increased development effort to create a set of objects for any given project.

The Open Library toolset helps bring a robust set of pre-built objects to WinCC OA and provides a base to build new objects from without having to start from a clean sheet each time.

Learn more about DMC’s HMI Programming and WinCC OA services and expertise. Contact us for more information or any project inquiries.

The post Siemens WinCC OA Open Library appeared first on DMC, Inc..

One of those improvements is the inclusion of Object Oriented programming constructs such as properties, enumerators, and classes into the CTRL language as of version 3.15. These new extensions are called CTRL++.

When these extensions were first released, some DMC engineers and I created the alpha release of the WinCC OA Open Library and released it for people to build off of. It’s a companion component to the Open PLC Library.

This code will undergo significant revisions and be released as a more full-featured package in the coming months. In the meantime, it’s a fantastic starting place to get your feet wet in CTRL++.

Creating highly configurable and reusable objects with OA is the bread and butter of the platform. CTRL++ extends the capability to do this rather significantly.

Any programmer is familiar with properties. Things like size, shape, font, etc.

CTRL++ gives us the ability to create properties. Properties like the typeOfbutton property listed here which allows dropping a button object on the screen and telling it how it will set the logic on button press.

The code to create these properties are placed in the “scopelib” (object scope global variables/methods) and are simple to create.

The type of the property shown here is “buttonType” which, as most programmers will know is not a standard primitive data type. That’s because it’s an enumerator! Here is the definition

The final key piece of this new CTRL++ functionality is the creation of classes. Here is a simplified piece of a class I’m currently working on.

Just instantiate the class in the scopelib of the object you want to use it with.

Then call a function.

Our thinking on best practice to implement CTRL++ has evolved a bit over the last year (mostly to encapsulate even more into the class structure), but go check out the OA Open Library code for examples on how to utilize this exciting new functionality.

Check out DMC's WinCC Open Architecture Development.

The post WinCC OA Object Oriented Programming with Ctrl++ appeared first on DMC, Inc..

The goal of the day-long event on July 28 was to promote discovery and discussion around the Oil and Gas industry's emerging automation and controls trends. All the presentations were well attended, offering a great opportunity to network in the area and learn about developing Oil and Gas technologies. 

My presentation, Powerful SCADA solutions: Is WinCC OA right for me?, demonstrated use cases for Siemens WinCC OA in Oil and Gas applications. The audience was excited by the idea of putting more configuration tools in the hands of their operators without having an integrator onsite. 

Check out my presentation below and feel free to contact me at james.condon@localhost with any questions.

The post WinCC OA Presentation at the Rocky Mountain Oil and Gas Conference appeared first on DMC, Inc..

Since DMC opened an office in Houston this year, the conference was a perfect opportunity to meet more people in the area. Jason Mayes and I attended and had a great time connecting with partners and distributors. We attended a presentation every session and found the conference to be an insightful introduction to the area.

I had the privilege of delivering a presentation titled Improving and Scaling SCADA Systems: Is WinCC OA Right for Me? The presentation covered a case study from a DMC distributed architecture project that was a good use case for WinCC OA. For our project, we did this with generators. The presentation paralleled these features as they would apply to similar features within Oil & Gas. I shared how our WinCC OA application might apply to distributed well sites, frack site trucks and skids, and pipelines. 

View the slide deck from my presentation below and feel free to contact me with any questions.

Learn more about DMC's Oil and Gas Engineering services.

The post DMC Presents at the 2015 Siemens Oil & Gas Conference appeared first on DMC, Inc..

Formerly known as WinCC Professionals, WinCC Specialists are SCADA experts when it comes to SIMATIC WinCC. DMC engineers have extensive experience with WinCC, WinCC 7 and WinCC OA among other Siemens platforms.

Learn more about DMC’s WinCC and WinCC OA services.

The post DMC Recognized as a SIMATIC WinCC Specialist appeared first on DMC, Inc..

WinCC OA is similar to a traditional SCADA system, but with a host of additional benefits. Due to its use of object oriented concepts and the ease at which it scales as your system expands, WinCC OA is an optimal solution for geographically distributed oil and gas applications. Throughout the course of the presentation, I will build upon solutions and concepts that DMC has already created to detail the many advantages and use cases for WinCC OA in oil and gas applications.

The Siemens Oil & Gas Innovations Conference aims to address issues, challenges, emerging technologies and new industry trends in the Oil &Gas Industry. Among other benefits, participants will be exposed to engineering and automation solutions to increase productivity.

Don’t miss my presentation Improving and Scaling SCADA Systems: Is WinCC OA Right for Me? during the Solution Breakouts at1:30pm in the Sunshine Special room.

Learn more about DMC's WinCC Open Architecture services.

The post DMC to Present at Siemens Oil and Gas Innovations Conference appeared first on DMC, Inc..

WinCC OA (OA) is the spiritual analogue to that philosophy in SCADA form. There are native drivers for Siemens and Allen Bradley PLCs as well as an OPC driver so it will work with nearly any modern controller.

Supporting a wide range of hardware is expected of a product that is targeted to the same space as Wonderware and Iconics. If this was the only thing that separated OA from Siemens' other offerings, we wouldn't be as excited about it as we are.

To understand the power of OA you have to understand that it is built upon itself. There is a core language that is derived from C and supports a long list of functions that are built in. The user interface is built on top of this core language and is user editable.

With this kind of open nature, there are a dozen ways to do anything and they are all equal. Consequently, it's not always easy to pick the best implementation path. While the script editor does have some shortcomings, it more than makes up for them with the flexibility and customizability it enables..

The powerful environment is complex and can have a steep learning curve, but once you are up to speed, the implementation possibilities are almost limitless:

• The alarm screen doesn't meet your needs? Modify it.
• You need to dynamically generate screens and then add them to the navigation system? Dig around in the deep parts of OA for your solution.
• Auto populate engineering parameters screen with auditing? Done.
• The tab key function for navigating between controls on the screen doesn't meet your needs? Override it with your own logic.

Every single example above, and more, was accomplished by DMC's team here and we were able to deliver the solutions our clients needed without ever resigning ourselves to "that's the way it is." As someone who has had to go to great lengths to work around technical limitations in the past, it is pretty amazing to be able to create anything I can dream of using these tools.

Our partnership with the WinCC OA team is growing rapidly as we develop the detailed knowledge to be effective in this platform. Look for a series of blog posts on the intricacies of WinCC OA over the next few months. 

As always if you’re interested in us implementing your SCADA system, please read more about DMC’s HMI and SCADA offerings.

The post Siemens WinCC OA – The Open Architecture SCADA Package appeared first on DMC, Inc..

The week kicked off with Monday night’s popular Connect Event. This casual cocktail event allowed attendees to build their network using a mobile-friendly app or website developed by DMC and Prism Systems to connect and share contact information. Attendees also got a preview of the cool Anki DRIVE racetracks that would be at the Siemens Solution Partner booth for the rest of the event. Attendees could choose to race their friends using conventional iPads or Siemens Mobile Panels developed by DMC to control the Bluetooth racetrack.

The rest of the week involved unique presentations, training classes, technology demonstrations, and finished off with a keynote by Eric Alexander and an after party at the Expedition Everest theme park!

DMC led four presentations throughout the week. Due to the great response, we’ve made the presentation slideshows available. Feel free to contact DMC with any questions regarding this content.

Getting the Most Out of WinCC OA – Kristie Shea
Explore some of the unique benefits of the Siemens Open Architecture SCADA platform and learn about specific projects where these object-oriented tools were used to meet demanding requirements without changing a single line of PLC code. Based on a project’s requirements, learn how to best choose between the three different Siemens SCADA offerings: WinCC OA, WinCC V7 or WinCC TIA Professional.

Best Practices for Selecting and Working with a Solution Partner – Tim Jager 
Get an insider’s view on how to best work with solution partners to maximize your return on investment. Learn when to use an integrator and how to choose the right integrator. 

Utilizing Siemens Best Practices When Leveraging Existing Rockwell Code – John Sullivan
Are you in the process of switching to Siemens hardware from Rockwell, but already have a working Rockwell program? Some people try to copy it over directly and miss out on the great opportunity that Siemens provides to make your code more flexible and reliable.

Extending S7 PLC Capabilities by Leveraging the Unique Strengths of the WinAC Platform 
– Alex Krejcie
Automation applications often have specific hardware and software requirements that pose integration challenges for system designers. The WinAC RTX platform is commonly used to provide deterministic real-time algorithm processing in a PC environment. See how DMC has been able to reduce application costs through hardware simplification and quicker development time by leveraging the unique capabilities of the WinAC platform.

The post View DMC’s 2014 Siemens Automation Summit Presentations appeared first on DMC, Inc..