NetLogic is C# code that is linked to Optix. Optix can call methods with parameters, set private C# variables, and has numerous C# Libraries integrated by default to assist with passing data between Optix and your C# code. Optix also allows you to link the monitoring of C# code to an Optix runtime instance.

Linking Variables

When creating NetLogic, you can define variables that interface with the C# code, and can be both written to and read from said C# code. You can also define variable categories to assist with organization.

• First, Variables are added onto the NetLogic object in Optix.

An example of variables attached to a NetLogic object

These variables can be referenced in the C# logic by utilizing the “GetVariable” method on our LogicObject.

• For any variables at the top-most level, simply call: LogicObject.GetVariable(“YourVariable”).
• For nested variables (such as variables under “Table” in the example above), define a new IUAVariable for the nested name (Tables in this case), and then reference the individual elements of that new variable.

private void ParametersSetup()

{
	DB_SERVER_IP = LogicObject.GetVariable("Server IP").Value;
	DB_SERVER_PORT = uint.Parse(LogicObject.GetVariable("Server port").Value);
	SERVICE_NAME = LogicObject.GetVariable("Service name").Value;
	DB_USERNAME = LogicObject.GetVariable("Username").Value;
	DB_PASSWORD = LogicObject.GetVariable("Password").Value;
	DB_QUERIES_FEEDBACK = LogicObject.GetVariable("Queries feedback");
	TABLES = LogicObject.GetVariable("Tables");

	TABLE_DESTINATION = TABLES.GetVariable("Destination").Value;
	TABLE_DISTANCE = TABLES.GetVariable("Distance").Value;
	TABLE_LOCATIONCHANGE = TABLES.GetVariable("LocationChange").Value;
	TABLE_EQUIPMENTSTATUS = TABLES.GetVariable("EquipmentStatus").Value;
	NUMBER_OF_DEVICES = LogicObject.GetVariable("Number of devices").Value;
	NUMBER_OF_EQUIPMENT_AREAS = LogicObject.GetVariable("Number of equipment areas").Value;
	CONNECTIONSTRING = $"Data Source=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST={DB_SERVER_IP})(PORT={(int)DB_SERVER_PORT})))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME={SERVICE_NAME})));User Id={DB_USERNAME};Password={DB_PASSWORD};";
}

private void ParametersSetup()

{
	DB_SERVER_IP = LogicObject.GetVariable("Server IP").Value;
	DB_SERVER_PORT = uint.Parse(LogicObject.GetVariable("Server port").Value);
	SERVICE_NAME = LogicObject.GetVariable("Service name").Value;
	DB_USERNAME = LogicObject.GetVariable("Username").Value;
	DB_PASSWORD = LogicObject.GetVariable("Password").Value;
	DB_QUERIES_FEEDBACK = LogicObject.GetVariable("Queries feedback");
	TABLES = LogicObject.GetVariable("Tables");

	TABLE_DESTINATION = TABLES.GetVariable("Destination").Value;
	TABLE_DISTANCE = TABLES.GetVariable("Distance").Value;
	TABLE_LOCATIONCHANGE = TABLES.GetVariable("LocationChange").Value;
	TABLE_EQUIPMENTSTATUS = TABLES.GetVariable("EquipmentStatus").Value;
	NUMBER_OF_DEVICES = LogicObject.GetVariable("Number of devices").Value;
	NUMBER_OF_EQUIPMENT_AREAS = LogicObject.GetVariable("Number of equipment areas").Value;
	CONNECTIONSTRING = $"Data Source=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST={DB_SERVER_IP})(PORT={(int)DB_SERVER_PORT})))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME={SERVICE_NAME})));User Id={DB_USERNAME};Password={DB_PASSWORD};";
}

private IUAVariable DB_QUERIES_FEEDBACK;
private string DB_SERVER_IP;
private uint DB_SERVER_PORT;
private string SERVICE_NAME;
private string DB_USERNAME;
private string DB_PASSWORD;
public IUAVariable TABLES;
private string TABLE_DESTINATION;
private string TABLE_DISTANCE;
private string TABLE_LOCATIONCHANGE;
private string TABLE_EQUIPMENTSTATUS;
private Int32 NUMBER_OF_DEVICES;
private Int32 NUMBER_OF_EQUIPMENT_AREAS;

private IUAVariable DB_QUERIES_FEEDBACK;
private string DB_SERVER_IP;
private uint DB_SERVER_PORT;
private string SERVICE_NAME;
private string DB_USERNAME;
private string DB_PASSWORD;
public IUAVariable TABLES;
private string TABLE_DESTINATION;
private string TABLE_DISTANCE;
private string TABLE_LOCATIONCHANGE;
private string TABLE_EQUIPMENTSTATUS;
private Int32 NUMBER_OF_DEVICES;
private Int32 NUMBER_OF_EQUIPMENT_AREAS;

Calling Methods

C# Methods can be called directly from Optix when the [ExportMethod] Line is added above said method. Any parameters associated with the Method will also be exposed, allowing you to set them dynamically from Optix, using a MethodInvocation or by linking them to events.

An example method invocation that shows all the [ExportMethod] methods from the Netlogic C# code

[ExportMethod]

public void SelectAllDevicesDestination()

{

…

[ExportMethod]

public void SelectAllDevicesDestination()

{

…

Monitoring Code

When NetLogic is created, Optix automatically configures the codespace (if utilizing VSCode) to attach to the Optix runtime instance, allowing you to monitor your C# card while the Optix application is running.

Visual Code is attached to the Optix Runtime when monitoring

Logging and Error Handling

Optix has a C# library for logging code that should be utilized, as it will output to the console in FT Optix Studio, as well as to the log file for the Optix application.

catch (System.Exception ex)
{
	Log.Error(MethodBase.GetCurrentMethod().Name, ex.Message);
}

catch (System.Exception ex)
{
	Log.Error(MethodBase.GetCurrentMethod().Name, ex.Message);
}

The location of Optix log files for an emulated project

Read the Other Articles in this Series

• FactoryTalk Optix Series 1 – Getting Started with FactoryTalk Optix
• FactoryTalk Optix Series 2 – Variables, Attributes, Dynamic Links, and Converters

The post FactoryTalk Optix Series 3 – NetLogic Overview and Examples appeared first on DMC, Inc..

Variables, Attributes, Dynamic Links, and converters are the building blocks of Optix UI design. Each variable has a number of attributes associated with it, and Dynamic links and Converters can be used to define a relationship between two or more variables/attributes.

A map of the relationships between Variables, Attributes, Dynamic Links, and Converters

Variables and Scope

Variable scope is influenced by the containers they are in. All variables with a given container (screen or panel) can access each other. Variables in nested panels have access to the variables in other nested panels and parent/children panels, and vice versa.

An example of variable scope extending to variables nested in other related panels

However, scope is limited when variables are not contained within a shared container, which happens most commonly with panels utilized in popups and panel loaders. However, the scope of panel loaders is unrestricted, so variables can be added to panel loaders and modified/updated anywhere in the Optix application, and the panels being loaded by said panel loader can then reference its variables to dynamically display information.

An example showing the limitations of scope when creation relationships between variables

To see an example of a panel loader utilizing variables to allow the Main UI to interact with individual panels being loaded by a panel loader, stay tuned for our upcoming Optix Series – Device Sidebar Example blog.

Attributes

Understanding attributes and their relationship to their parent variable is necessary to form complex Dynamic Links for UI functionality. Below is a list of the most common variable attributes.

To see an example of different attributes being used to create a clean, complex solution, stay tuned for our upcoming Optix Series – Device Sidebar Example blog, which utilizes NodeId, BrowseName, and DataType BrowseName attributes.

Converters

• Conditional Converter
  • Sets the output variable’s value based on a true/false evaluation of the input.

• Engineering Unit Converter
  • Scales the output linearly based on the input.

• Linear Converter
  • Scale the output based on a defined slope and intercept.

• Key-value Converter
  • Matches an output value to the input “Key”.

• Expression Evaluator
  • Evaluates an expression consisting of one or more input variables.
  • To see all of the valid operators that can be used in an expression, see Rockwell’s documentation.

• String Formatter
  • Outputs a string that can be defined using variables and various formatting options.

Dynamic Links

Dynamic links are defined relationships between two or more variables. Dynamic links can implement converters to create complex relationships and can be pointed at both variables and attributes.

Aliases

Aliases are a unique property type that allows you to specify the structure of a variable.  This is useful when creating panels that should be referencing a specific Data Types, such as a motor or valve Data Type. An alias allows you to reference all the elements of the defined Data Type, while still allowing the alias variable to be linked dynamically, allowing graphics to be updated in real time, such as being able to swap which motor a panel is pointing to.

An example of an alias to a Motor Data Type

An example use case of aliases is for a device sidebar that utilizes a panel loader to swap in faceplates panels for different types of devices. The panel loader would have a NodeId variable (Let’s call it “Device Tag”) that would be updated at runtime to point to a desired device tag. For each device type, one panel would be created with a tag alias with the “Kind” attribute bound to the UDT of said device and the “NodeID” attribute bound to the “Device Tag” Attribute on the panel loader. Typically, you cannot create property bindings between variables that are not within the same window or screen (or the same panel for panels that are not directly placed on windows or screens), but panel loaders can be referenced regardless of project scope, allowing us to make use of the “Device Tag” variable we attached to ours.

For an in-depth example, Stay tuned for our upcoming Optix Series – Device Sidebar Example blog.

Read the Other Articles in this Series

• FactoryTalk Optix Series 1 – Getting Started with FactoryTalk Optix
• FactoryTalk Optix Series 3 – NetLogic Overview and Examples

The post FactoryTalk Optix Series 2 – Variables, Attributes, Dynamic Links, and Converters appeared first on DMC, Inc..

This blog series covers the essentials to creating your own HMI and SCADA applications using Optix as well as some helpful examples for common applications.

Installation

FactoryTalk Optix Studio is installed via FactoryTalk Hub, and it is the IDE used to program Optix projects. You can either download the IDE application or utilize a web-based IDE if your license supports it.

The Optix Runtime tools are also installed via FactoryTalk Hub, and they are required on any machine that is going to run an Optix application.

FactoryTalk Hub: which hosts a number of FT applications (including FactoryTalk Design Studio for Optix)

Licensing and Pricing

Optix licensing is done on a token-based system, with more features requiring more tokens, and, therefore, a larger license. Generally speaking, the largest contributors to token usage are multiple concurrent web clients, OPC-UA connections, or database connections.

Examples of features that affect the sizing of your application include the following:

• Controller connections
• Multiple web clients
• Alarming
• Recipes
• PDF reports
• Data logging
• Database connectivity
• OPC UA connectivity

For more information on tokens and licensing, please see Rockwell’s documentation.

Presentation Engines

Presentation engines are responsible for rendering and displaying UI elements during runtime. There are two available presentation engines that can be used simultaneously – the native presentation engine and the web presentation engine.

The native presentation engine launches the project in its own window as an application.

The web presentation engine hosts the application on a web server, accessible via the defined web page. Multiple concurrent web clients can access the application (if multiple connections are defined in the web presentation engine), but more concurrent clients require more tokens.

Optix can make use of session-specific tools to allow concurrent clients to have different screens/panels open, have different users logged in, and display different information, provided that the Optix project was designed with multiple clients in mind.

An example configured Web Presentation Engine

Style Sheets

Style sheets allow the definition of default colors, shapes, sizes, and other UI element configurations. A project’s style sheet can be swapped during runtime. Some properties can be defined both in the style sheet and in an individual UI element. In the case that a property is explicitly defined for an individual element, it will override the style sheet.

An example Style Sheet

Screens and Panels

FT Optix uses screens, panels, and popups as the main methods for displaying UI elements. Screens and popups can both contain multiple panel loaders, which can be used to dynamically change displayed content when a defined action is performed, such as hitting a button.

To see panel loaders being implemented to create a dynamic device sidebar that changes what device it controls (and the associated UI elements) at the push of a button, stay tuned for our upcoming FactoryTalk Optix – Dynamic Device Faceplate blog post.

A panel loader that is a part of the main overlay of an application. It has the ability to load either a Motor or a GroundRack panel into the panel loader.

A runtime instance with the “Motor” panel loaded into the panel loader

A runtime instance with the “Ground Rack” panel loaded into the panel loader

Converters

Converters allow you to modify variables dynamically based on other variables. For instance, a key-value converter could change the text displayed in a string variable when a different integer variable’s value changes, and an engineering unit converter can be used to scale variable values differently.

There are more converter types and use cases that were not mentioned above. For more information on converters, stay tuned for our upcoming FactoryTalk Optix – Variables, Attributes, Dynamic Links, and Converters blog post.

A Key-Value converter that parses an integer out into valve status strings

Dynamic Links

Dynamic links are used to define relationships between two or more variables or attributes within the FT Optix project. Complex dynamic links allow the use of built-in converters, allowing further customization of UI elements.

For further information on Property Bindings, stay tuned for our upcoming FactoryTalk Optix – Variables, Attributes, Dynamic Links, and Converters blog post.

For an example of leveraging complex dynamic links, stay tuned for our upcoming FactoryTalk Optix – Dynamic Device Faceplate blog post.

A dynamic link that performs mathematical operations on several variables to return an adjusted distance

Events

Events call methods when a specific trigger happens, such as a button being pressed or a variable’s value changing. Events can be added onto most UI elements, and they can trigger multiple methods.

Methods

Methods are called by events. FT Optix has a number of built-in methods, but custom methods can be defined through NetLogic as well.

You can also create pre-defined method invocations, which allow the calling of methods with pre-defined parameters.

A list of common methods available in FT Optix

A custom method invocation for renaming a MySQL Database table

NetLogic

NetLogic allows C# code to be integrated and run in an FT Optix project. FT Optix can call parameterized methods, and they can send and receive variables with the C# project.

For further information on NetLogic, stay tuned for our upcoming FactoryTalk Optix – NetLogic Overview and Examples blog post.

An example NetLogic snippet that returns a localized time

Data Stores

Data stores are databases used to store values from different loggers and NetLogic (if you so choose). You can either use an embedded database, which is a simple SQLite database created with minimal overhead, or you can choose to create a connection to a database (SQL Server or MySQL). Other database types may be supported through ODBC connections, but they have not been tested or confirmed yet.

Loggers can be linked directly to a data store and will automatically configure tables for themselves on said database.

An example data store with an “Alarm Logger” linked to it, auto generating the necessary tables

Communication Drivers

Communication Drivers allow defining communication paths to PLCs and other devices, as well as the importing of tags and other information to be used in the Optix project. A list of the currently available communication drivers is available below.

All available communication drivers in Optix

The tag importer display from an example Rockwell Ethernet Driver linked to a PLC

Template Library

Optix’s Template Library

The template library stores templates created by Rockwell and allows you to create/import your own libraries as well. Some examples of useful templates that are included with Optix are:

• Alarm Grid
• Alam History
• Alarm Banner
• User Login Popup
• Confirmation Dialog
• Date and Time Display
• File Selector
• File System Browser
• Alarm Importer and Exporter
• Alarm Logger

Read the Other Articles in this Series

• FactoryTalk Optix Series 2 – Variables, Attributes, Dynamic Links, and Converters
• FactoryTalk Optix Series 3 – NetLogic Overview and Examples

The post FactoryTalk Optix Series 1 – Getting Started with FactoryTalk Optix appeared first on DMC, Inc..

This graphic may come in many forms. A steam plant, for example, may utilize a piping and instrumentation diagram (P&ID) to illustrate the movement and temperature of fluids throughout the building. The packaging room of a product manufacturing plant may utilize a CAD drawing of manufacturing equipment with overlays to indicate status. In any case, the graphic should be easily recognizable, quickly interpretable, and useful to a wide range of users.

In this blog, we will demonstrate how to create a custom animated graphic that satisfies these requirements for a SCADA application built in Ignition Perspective.

Ignition is one of the fastest-growing SCADA/HMI platforms Inductive Automation developed, and Perspective is the web-friendly visualization module that hosts user interfaces accessed from any web browser. Our clients often implement Perspective applications that are simultaneously accessed from industrial HMIs, tablets, laptop computers, and cell phones with ease.

The custom graphic created in this tutorial was implemented in the Ignition Perspective SCADA application of a client operating a consumer goods packaging plant. This tutorial is broken into the following sections.

1. Converting existing illustration to a web-friendly format
2. Importing drawings to Perspective
3. Creating an effective graphic with dynamic bindings

The following tools are needed to follow along with this guide:

• Inductive Automation Ignition, including the Perspective module and Designer installation —
• Adobe Creative Suite, including Photoshop and Illustrator
  • Note – free programs, such as Gimp, can also be used to follow this tutorial. Because DMC is a subscriber of the Adobe Creative Suite, which happens to provide some of most efficient tools for the job, these steps are not outlined in detail

Keep reading for step-by-step instructions to convert a 2D CAD drawing to a customizable Perspective graphic.

Converting Existing Illustration to SVG

A major benefit of Ignition Perspective is the ability to embed custom scalable vector graphics (SVGs) in the user interface. An SVG is a drawing file, like a CAD or PDF file, consisting of defined paths rather than fixed pixels. This difference allows the graphic to scale predictably without losing definition or quality. Scalability is an excellent quality for a graphic that will be displayed on devices with varying resolution. SVGs provide a path to custom graphics in Perspective without the need for a Designer-based illustration tool like that used in the Vision module.

Option 1: Convert straight to SVG

Some drawing files may be imported directly to Adobe Illustrator and saved to an SVG. This is the best-case scenario because only the pixels of interest will be saved from the drawing file. To do this, we simply open the file in Adobe Illustrator, crop if needed, and Export As an SVG. At this stage, ensure each piece of equipment in the drawing is separated into objects with appropriate names. This can be accomplished in Illustrator by creating layers with apt naming prior to export.

To confirm your SVG is in the correct format, open it with any text editor. The SVG should consist of some header information describing styles, size, and viewbox as well as a list of path objects. These objects will be displayed in Perspective as individual elements.

Figure 1: Example of CSV with single element, "sorterFill." Note: that path has been cutoff for conciseness.

Option 2: Extract drawing with image editing software

Other drawing files are not provided in a scalable format or are too complex to be redrawn on your machine. In this case, we can use an image editing software to extract the shapes of interest from the provided drawing.

Step 1: Import illustration to Photoshop (or other photo editing software)

For this example, we start with a customer’s 2D drawing file in the locked DWG format. Similar processes can be followed for PDFs, DWFs, PNGs, etc. This file contains the top-down drawing of the packaging room floor. Since our photo editing software cannot directly import a DWG file, we will first print the drawing to a high quality TIF image. We will do this with  DWG TrueView, a free program from Autodesk. The output filetype is not as important as the quality and size of the image. We only need to convert it to a filetype that our image editing software can process. 

This TIF file can be dropped into the image editing software. In this guide, we will use Adobe Photoshop. Once dropped into Photoshop, adjust the image to fill your canvas, and rasterize it with the confirmation button.

Step 2: Use the Magic Wand tool to select the parts of the drawing to be animated

Hint: unchecking the “Contiguous” box in the Magic Wand properties ribbon allows for quick selection of background in grayscale images. In our example, we use the Magic Wand to quickly select all white pixels. Right click > Select Inverse yields the selection of all grayscale pixels. 

Step 3: Layer Via Copy

Right click the selection and create a new layer via copy using the provided menu. The original layer can be disabled to view only the selected pixels.

Step 4: Clean up Selection

At this point, we can use our photo editing software’s eraser tool to remove pixels from the animation. In our example, we will remove electrical enclosures and repeated hardware.

Step 5: Separate equipment into unique layers and create Fill Layers

Use any selection tools necessary to select and separate the drawing into equipment regions. Separate the regions by right clicking the selections and creating new layers via cut. When finished, we should have a layer for each piece of equipment and nothing else. Delete any background or leftover layers.

Once the equipment is separated into layers, each one must be used to create a new Fill Layer. A Fill Layer is needed to vectorize the pixels in preparation for exporting to SVG. First, select all the pixels for a given equipment layer. This can be done by right clicking the layer preview and selecting “Select Pixels.

Once the pixels are selected, right click the selection, and select “Make Work Path.”A popup will prompt the user for a tolerance. This setting may be adjusted if results are not satisfactory. For our example, we selected a tolerance of 1 pixel. Images with denser pixel date may not require such a tight tolerance.

Create a new Fill Layer using the dropdown navigation: Layer -> New Fill Layer -> Solid Color. Select a neutral color, presumably black, and name the layer appropriately. Names selected here will be displayed as properties in the Perspective project object, so they should be intuitive.

Step 6: Export as SVG

Once a fill layer is created for each division of equipment, disable all other layers. Only the fill layers should be displayed in the editing window. At this stage, we are ready to export our SVG. Use the dropdown navigation to select Export As, and select SVG from the dropdown menu in the popup that appears.

Note: you may want to ensure the drawing is in the proper orientation. This step is not critical but will make responsive resizing in Perspective windows much smoother. Image rotation in Perspective can be accomplished, but it currently requires nesting in a coordinate container.

Import SVG to Ignition Perspective Project

Now that the SVG was created from the provided system drawing, it can be imported to the Ignition designer. The easiest way to do this is to drag and drop the file into a blank Perspective view. For this example, we are employing a flex container. Ensure that the SVG is embedded and not linked in the view.

Once the drawing is embedded, the component will appear in the Project Browser. Browse the `elements` property to ensure that all layers have imported successfully as separate elements.

For our example, we set Grow and Shrink properties to 1and allowed the basis to be set automatically. This ensures maximum responsiveness in embedding views. It may also be reasonable to set minHeight and minWidth constraints on the SVG component, or flex container, if needed for a given application.

Create Intuitive Overlays and Animations in Perspective

Each element of the SVG component can be customized like other Perspective components. Namely, a “style” object may be defined for each element to employ standard Perspective CSS-esque customization. For this example, we will be animating/coloring the pieces of equipment drawing based on OPC status tags using Perspective styles.

Step 1: Create Perspective styles

For this example, we will use style to change the color and of each piece of equipment. This is not the only way of animating equipment with styles. Border, transparency, and visibility can also be customized for a more inclusive design. Let’s first define our “alarm” class. When this class is applied, we want the equipment to flash between red and black at a fixed rate. Use the Timing and Shape/Fill properties to accomplish this.

Step 2: Create dynamic bindings

Once styles have been created, they need to be dynamically assigned to the class property of each element of the SVG. This can be accomplished in a few ways:

Option 1: Create bindings for each element

For simple drawings, a binding may be defined for each object in the SVG. For each element, create a “style” object with a “classes” value. This value will be bound to the appropriate OPC tag. In our example, we use an indirect tag binding to retrieve the equipment status from tag UDTs. Two transforms are then applied: a script transform to check tag quality — end user wanted custom error behavior — and a map transform to select the appropriate predefined style from an enumeration.

Option 2: Update style classes via scripting

For complicated drawings with many pieces of equipment, scripting may be a more efficient use of developer time. Consider creating a timed event or a custom root property with a polling expression binding to execute the following pseudo code:

This allows the styling to be set without configuring individual bindings on each element. For this code to work, the names of SVG elements must match tag names in the tag provider UDT that is supplying status information, and the eqPath parameter of the view must be a valid tag path to a UDT instance.

Once our bindings have been created, we are ready to embed the animation throughout the project.

In this guide, we've learned how to create a custom illustration and animation from a 2D drawing file and import it to an Ignition Perspective project. To learn more designing dynamic Perspective projects, see Caz’s series of blogs listed below!

Learn more about DMC's Ignition expertise, and contact us to get started on your next HMI, SCADA, or MES project!

See other blogs related to this topic: Creating Dynamic Ignition Perspective Projects
Part 1: Bindings and Transforms
Part 2: Button Event Actions
Part 3: Embedded Views and Flex Containers
Part 4: View Parameters, Indirect Bindings, and Flex Repeaters

The post Creating Custom Graphics for SCADA HMIs with Ignition Perspective and Photoshop appeared first on DMC, Inc..

My experience drawing graphs on Siemens HMIs has mostly involved trend views which show live data as a function of time. Visualizing cam profiles for this project involved datalogging methods coupled with an f(x) trend view.

Two resources that were imperative to setting this up were this Siemens blog (Creating an f(x) Trend View for Comfort Panels and WinCC Runtime Advanced) and this DMC blog (Custom Data Logging using a Siemens Comfort Panel and VB Script). I found the implementation very interesting and highly encourage the use of this visualization strategy for future motion control projects.

This blog in particular will take you through the step-by-step of creating a basic project, adding the VB Script for datalogging, and configuring your trend view.

Step 1: Array Setup

For the purposes of this application, we set up eight arrays to capture key position data from each axis. These arrays are local to the HMI so that operators can preview changes. When they are satisfied with the results of the preview, they can run a separate script that copies the HMI data to the PLC. To set up my test application, I defined all of these arrays in a tag table on the HMI.

Then, I created an HMI screen with I/O fields for each of these array values.  

Step 2: Add Script to Log Data

Now that we can adjust our array values from the HMI, it’s time to create some data logs. To display our data on the built-in f(x) trend view, we need to ensure that all the (X, Y) value pairs we will be graphing have identical timestamps. We are using a script to achieve the data logging to ensure that an identical timestamp is used for all data, the values can be archived on demand, and that the input arrays are stored as a series of individual values. 

The script is the meat and potatoes of this whole project, so we’ll go through it chunk by chunk. One important thing to note is that Windows PCs, like the computer I am simulating this project on, use slightly different syntax for file-handling functions than Windows CE, which is the operating system running on Siemens Comfort panels. Please see “Changes for Windows CE” below for the updates that need to be made to the script for deployment on actual hardware.

The first step in our script is to declare variables. I determined it was easiest to create 4 separate trend logs for our 4 separate trends. The split sign in this CSV file is set as a semicolon for this example. Data delimiters may vary by the country setting of the operating system.

Next, we assign the values in our tables to arrays that live on the HMI. We also create our CSV files that will hold our logs. The filename of each CSV file has a “0” appended on the end – this was important during testing to get it to match up with our historical data configuration (keep reading for more information on this). 

Now that the old files are gone, we must create new files to store new data. Each file is instantiated with a header.

Next, we get to add all of our data.

The last bit of our script opens the logs and ends the function.

Finally, I created a button on the graph screen to call our script. The return value is populated if any errors occurred during our script execution. The button also re-loads the screen to ensure the trend refreshes with the new values.

In summary, the following internal HMI tags are used in this demonstration:

Step 3: Configure Historical Data

Now we need to set up our data logs and logging tags under the “Historical data” section of our HMI project. These log names and process tags match what I am using in my script. 

For the path, since I am simulating this project on my computer, I used my C: drive. To do this, I had to ensure that my folder sharing permissions were set to allow sharing.

Step 4: Configure Trend View

On my trend screen, I created an f(x) trend view.

For my project, I have a single X axis with units in millimeters.

I created two Y axes for displaying trends in both millimeters and degrees. 

Step 5: Simulate & Test

Since this project only uses tags that are internal to the HMI, I was able to simulate and test the HMI by itself. I randomly generated some values to put in my input table, and then I navigated to my chart view and ran my script by pressing the “update trend” button. 

Step 6: Changes for Windows CE

Steps one to five work great for creating a standalone project that can be simulated on a Windows PC; however, Windows CE and Windows PC have some different syntax in VBScript when it comes to handling the file system.

First of all, creating the files and instantiating the file system look slightly different (see below for a comparison). In this version of my script, the Windows PC syntax has been commented out and the Windows CE version is active.

Likewise, deleting our files requires a slightly different file system command.

Setting up our archives uses a different command as well.

See the image below for differences in how to create a header for the data log.

Conclusion

This use of data logging and trend views is pretty nifty! Our client was especially grateful for the ability to visualize cam profiles before running them on their machine. I hope this blog helped to clarify some of the steps in the process. I look forward to finding more creative ways to utilize this script in the future. 

Learn more about DMC’s Siemens expertise and contact us for your next project.
 

The post Visualizing Cam Profiles for Siemens Comfort Panels appeared first on DMC, Inc..

For my example, I will demonstrate on a TP700 Comfort Panel, although the same basic procedure can be used for a Basic Panel or an Advanced Runtime system. To start things off, I've created three internal HMI tags: An alarm word (UInt) for triggering of my example alarm, a string to contain the name of the logged in user, and a real tag for my process value example.

First, I've written a short script to capture the name of the logged in user and created a task to call my script on any user change event. Obviously, this part of the demo is specific to WinCC Comfort or Advanced as the Basic panel will not support scripting, but it will not affect our alarm text demo. Next, I've created several users to allow myself to log in to our example HMI.

Now I've created a single discrete alarm, triggered off of Bit 0 of my alarm word with some simple static text, "Max Speed Limit Exceeded."

Let's pretend for the moment, though, that we would like to include the actual limit in the alarm text for both display and posterity, as well as the operator that forced the system to exceed that limit. If the limit was not configurable, we could hard code it in the message. And if there were only a few users, we could potentially create an alarm for each user. However, if users can be created dynamically and the limit is a configurable parameter, there is no way of creating all of the possible alarm messages that may occur. Luckily, we can create dynamic alarm text.

To create dynamic alarm text, select the alarm from the alarm list and view alarm properties. Now, right-click in the "Alarm Text" field and you will see two options: "Insert tag field…" and "Insert text list field…"

I'm going to use "Tag Field." Notice that when you select it, a dialog will open allowing you to configure the field. In this example, I will use the process value tag I previously created, and configure it to display as a decimal with length three. As you can see, it is also possible to use Text Lists directly within an alarm, which allows you to create even more dynamic alarms.

Next, I added in an additional tag to display the name of the operator.

That's it. Now I'm going to set up a quick example screen with an alarm viewer and controls for setting my process tag and triggering my alarm, as well as displaying the currently logged in user. Now if I trigger my alarm, you can see that my alarm text is dynamically generated.

I hope this is helpful!

Learn more about DMC's PLC Programming services and contact us to get started on your next PLC Programming project.

The post Customizing HMI Alarm Text in TIA Portal appeared first on DMC, Inc..