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..

Common questions that may have led you here:

The Basics

In this section, we will cover how to do the minimum viable work to get display changes working. This process will cover the basics and allow you to get working on your own, but feel free to stick around if you want to improve your coding and architecting skills.

Creating a Trigger

In this section, I am going to explain how to create a global trigger. This just means that we are going to set up a display such that the trigger is always being updated so you can initiate a change from any display.

Firstly, we are going to create a new display. You can call this display PopupHandler if you want it to be sufficiently descriptive. On this display, we are going to add a numeric input. Set the expression to be your trigger condition.

Once you’ve got the numeric input set up, right click the background of the display and select Display Settings... . Make sure the following properties match between your displays:

Now, we are going to make the PopupHandler silently load and stay cached and updated so the numeric input we have created is always loaded. Create a macro and call it startup. When the macro opens, add the following command on a new line:

Display PopupHandler /ZA

Now that we have the macro ready, we are going to add it to our client runtime. Edit your .cli file and make sure you’ve got the startup macro selected to run on startup. Once this is done, the macro should execute on startup and load the PopupHandler display into our cache.

Using VB to Set a Display

Now that we have the trigger ready, we are going to add the corresponding VB Script. Select the numeric input on your PopupHandler display, right click, and select VBA Code... . You should see the following:

The subroutine (sub) you see of the form NumericDisplayName_Change is the script that is going to run when our condition changes. To trigger our display change, we are going to add the following line of code inside the subroutine (replace “DisplayName” with the display you want to appear).

ExecuteCommand ("Display DisplayName")

With that, you should be ready to go. Go ahead and restart your client and try triggering your condition. Ideally, you should see the popup or display you specified appear when the condition changes. If you do, you’ve got the minimum viable product and should proceed to the “Let’s Make it Better” section to refine your implementation.

Let’s Make it Better

We can do better and you know it. If you want to impress the future engineers who will look at your work, then I suggest you get to the end of this section.

Better Naming Practice

Let’s start by changing the name of our component. Go into the component properties and set the name to something more descriptive — in this case, we will use PopupEventTrigger. If we observe the VB Script again, then we will see the name of the subroutine has been changed to reflect what was done in FactoryTalk View Studio.

Let’s also leave a clear visual indication of the work we have done. Next to the numeric input you are using, go ahead and add a text box and describe what is happening here. This will make it readily apparent to other engineers that there is VB Scripting going on behind the scenes.

Case-By-Case Events

Instead of triggering any time we see the value change, let’s consider the value we are seeing. In this case, we are going to nest another condition that checks if the value of our trigger is “1”. With this new implementation, we should only see our change when we have a rising edge signal.

Private Sub PopupEventTrigger_Change()
    ' If trigger value is rising '
    If PopupEventTrigger.Value = 1 Then
        ' Change Display '
        ExecuteCommand ("Display Popup")
    End If
End Sub 

Private Sub PopupEventTrigger_Change()
    ' If trigger value is rising '
    If PopupEventTrigger.Value = 1 Then
        ' Change Display '
        ExecuteCommand ("Display Popup")
    End If
End Sub 

Private Sub PopupEventTrigger_Change()
    ' If trigger value is rising '
    If PopupEventTrigger.Value = 1 Then
        ' Change Display '
        ExecuteCommand ("Display Popup")
    ' If trigger value is falling '
    ElseIf PopupEventTrigger.Value = 0 Then
        ' Close Display '
        ExecuteCommand ("Abort Popup")
    End If
End Sub

Private Sub PopupEventTrigger_Change()
    ' If trigger value is rising '
    If PopupEventTrigger.Value = 1 Then
        ' Change Display '
        ExecuteCommand ("Display Popup")
    ' If trigger value is falling '
    ElseIf PopupEventTrigger.Value = 0 Then
        ' Close Display '
        ExecuteCommand ("Abort Popup")
    End If
End Sub

Error Handling

Let’s prevent errors from interfering with our operation. If there is an issue with the connection to the PLC, then the numeric display may have an error value. Unfortunately for us, this change to an error value counts as a value change and will trigger our display change subroutine. To avoid this, we will wrap our logic in an if statement that checks if there is an error value in our component.

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If Not IsError(PopupEventTrigger.Value) Then

        ' If trigger value is rising '
        If PopupEventTrigger.Value = 1 Then
            ' Change Display '
            ExecuteCommand ("Display Popup")
        End If

    End If
End Sub

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If Not IsError(PopupEventTrigger.Value) Then

        ' If trigger value is rising '
        If PopupEventTrigger.Value = 1 Then
            ' Change Display '
            ExecuteCommand ("Display Popup")
        End If

    End If
End Sub

Alternatively, we could exit the subroutine early if there is an error.

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If IsError(PopupEventTrigger.Value) Then
        Exit Sub
    End If

    ' If trigger value is rising '
    If PopupEventTrigger.Value = 1 Then
        ' Change Display '
        ExecuteCommand ("Display Popup")
    End If
End Sub

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If IsError(PopupEventTrigger.Value) Then
        Exit Sub
    End If

    ' If trigger value is rising '
    If PopupEventTrigger.Value = 1 Then
        ' Change Display '
        ExecuteCommand ("Display Popup")
    End If
End Sub

Let’s Make it Scalable

While this solution works great for changing to one specific display, it doesn’t work great at scale. Imagine, for a moment, having to repeat the process of creating a new numeric input and writing the Visual Basic subroutine for every display you want to change to. Needless to say, this proposition elicits feelings of dread.

To avoid this monotonous task, we are going to discuss a couple possible architecture changes to support additional display changes.

Potential Architectures

There are, of course, more options than the two I will address here; however, they should generate some considerations for designing the architecture that fits best for your uses.

Custom Display Indexing

The numeric display we have been using to trigger our subroutine is not limited to a 1 or 0, so let’s make use of it. Change the expression to read an int on the PLC, and let’s move to a display based on what int is shown.

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If IsError(PopupEventTrigger.Value) Then
        Exit Sub
    End If

    Select Case PopupEventTrigger.Value
        Case 1
            ExecuteCommand ("Display Popup1")
        Case 2
            ExecuteCommand ("Display Popup2")
        Case 3
            ExecuteCommand ("Display Popup3")
    End Select
End Sub

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If IsError(PopupEventTrigger.Value) Then
        Exit Sub
    End If

    Select Case PopupEventTrigger.Value
        Case 1
            ExecuteCommand ("Display Popup1")
        Case 2
            ExecuteCommand ("Display Popup2")
        Case 3
            ExecuteCommand ("Display Popup3")
    End Select
End Sub

This approach is handy as it allows you to map integer values to displays, similar to how the process works in ME. All the display changes are handled here in this subroutine; however, you will have to manually add each new display you want to transition to. To avoid this, we can have the PLC pass a string indicating a destination display.

Passing Strings from the PLC

By setting a string on the PLC for the HMI to read, we can indicate any display we want to transfer to! For simplicity, let’s create a string display on our PopupHandler screen to reference in our VBA. There, we can change our command to display whatever display is referenced in the string. Make sure that the string display has plenty of characters, as it will trim the PLCs string to the specified character amount. Additionally, make sure to expose the string display to VBA from the property panel with the option “VBA Control”.

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If IsError(PopupEventTrigger.Value) Then
        Exit Sub
    End If

    ' If trigger bit rising '
    If PopupEventTrigger.Value = 1 Then
        ' Trigger display change based on the value of the passed string '
        ExecuteCommand ("Display " & DisplayNameString.Value)
    End If
End Sub

Private Sub PopupEventTrigger_Change()
    ' Make sure there is no error '
    If IsError(PopupEventTrigger.Value) Then
        Exit Sub
    End If

    ' If trigger bit rising '
    If PopupEventTrigger.Value = 1 Then
        ' Trigger display change based on the value of the passed string '
        ExecuteCommand ("Display " & DisplayNameString.Value)
    End If
End Sub

If you want help with your FactoryTalk View SE project or PLC development, contact us today for your next project — we would love to help!

The post Triggering Popups and Display Changes in FactoryTalk View Site Edition from the PLC appeared first on DMC, Inc..

Our application had some lag when loading new screens because of the large amount of tags required to populate the screens. FTV SE can pull up to about 200 tags from a Micro 850 per second; with larger PLC programs taking more time to send tags.

For smaller HMI/PLC applications, all of the PLC tags from a Micro 850 can easily be pulled quickly while loading a screen. For larger applications, there may be some delay after opening a screen before all of the tags on a screen are loaded from the PLC and ready to populate their indicators.

However, FactoryTalk lets you load screens snappily, even when talking to smaller PLCs or when large amounts of data need to be loaded.

A few tips and tricks are below!

1. Decrease Maximum Tag Update Rate (per Screen) – This rate controls the shortest possible time it will take the FactoryTalk application to acquire or send a tag. This is important for buttons and indicators that need to have a fast response, as well as for loading screens quickly.
   1. To access this setting, right-click on a screen, select Display Settings, and under the Properties window, select the drop-down for Maximum Tag Update Rate. The default setting is 1 second; this may appear slow for most applications. A rate of 0.25 or 0.1 seconds will usually allow the screen to react without visible lag.
      
   2. This may have different levels of impact with different PLC platforms – this should be a good solution for fast performance with the Logix line of processors. We found that additional steps were needed with the smaller Micro800 line.
   3. Keep in mind that your application may not be able to keep up with faster Tag Update Rate setpoints. This is dependent on the number of tags you have on the screen and the number of tags that are being fetched in the background (read on to learn more about background fetching!)
2. Add Screen Caching – FactoryTalk View Site Edition's default behavior is to close any screens that aren't actively being displayed. This minimizes PC resource usage and allows you to edit screens in an active application (one of my favorite features). However, you can individually configure each screen to be cached, so that the screen is kept in memory even when it isn't shown on the screen. This greatly improves behavior for laggy screens.
   1. To access this setting, right-click on a screen, select Display Settings, and under the Properties window, choose Yes for Cache After Displaying.
   2. You also have the option to select whether the screen is Always Updating or not. Always Updating is a good selection for screens that don't populate immediately even when cached – we found this was the best choice for most of our larger screens with lots of tags. Keep in mind that if the screen is Always Updating, it will always be polling tags from the PLC. This may influence the update rate of tags on other screens in your application.
      
3. Add Screen Pre-Caching – If Screen Caching improved your application's performance, you may also want to consider Pre-Caching your screens! Pre-Caching pre-loads the screens while the application is starting up, without displaying them on the PC. Cached screens without pre-caching may still be slow to load the first time they're displayed; pre-caching makes the display pull from an already cached screen the first time that it's loaded.
   1. This can be done via a Startup Macro. Create a macro in the Explorer pane under Logic and Control > Macros. Right-click to create a New Macro.
      
   2. In the Macro editor, add a call to the "Display" function for each screen that you'd like to precache. Use the \Z flag to cache a screen without marking it as Always Updating. Use the \ZA flag to cache a screen and set the screen to Always Update. (A full description of this function and possible flags is available in the FTV help files as "FactoryTalk View Site Edition Help > FactoryTalk View commands > Graphics commands > Display")
      
   3. When launching or creating your FTV SE Client with the FactoryTalk View SE Client Wizard, include your macro as the Startup Macro.
      

If you follow these tips, you should have a fast and snappy HMI!

Learn more about DMC's Rockwell Programming Services.

The post Maximizing FactoryTalk View Site Edition Performance appeared first on DMC, Inc..

Before we start, you’ll need all of the components networked together and powered on. You’ll also need a PC with all the relevant Rockwell software installed. Once you’ve accomplished this, give yourself a pat on the back and read on!

Firmware Setup

Congratulations, you’ve just powered up your shiny new Allen-Bradley PLC for the first time. Now what? If it’s fresh out of the box, you’ll likely have to install the firmware. To do this, you’ll need a Rockwell tool called ControlFLASH. Believe me, it’s as exciting as the icon makes it look, just without the lightning bolts.

With an Ethernet cable connected directly between your PC and the PLC, follow the prompts to select your model number and firmware revision. Navigate to the PLC in RSLinx and click OK. Accept all the warnings that tell you not to do this on a live system. If you are doing this on a live system – STOP! When the firmware upgrade completes, the PLC will begin scrolling its MAC address across its display (if applicable). That means you’re ready to assign IP addresses.

Setting the PLC IP Address

The factory default for Allen-Bradley PLCs and many peripherals is to ship with BootP/DHCP enabled. However, DMC finds that best practice is to setup static IP addresses for all devices on the control network. This makes life much easier in the future, especially with integrating SCADA, remote access, and device troubleshooting. To disable BootP and give the PLC a static IP address, you’ll need another Rockwell tool called BootP DHCP EtherNet/IP Commissioning Tool.

Locate your PLC by its MAC address and choose “Add Relation.” Next, right-click on the PLC (now in the lower window pane) and choose “Disable BootP/DHCP.” Enter the desired network settings and click OK. Wait for the successful confirmation message. It’s always a good idea to stop at this point and power cycle the system. If the PLC retains its IP address, go ahead and move on to the next step. If not, try this step again until the IP settings stick. If you’re having issues with the BootP/DCHP tool, check out Lillian’s blog post for tips.

Download your program

At this point, your PLC is ready for operation. With your program open in RSLogix, select “Who Active” from the “Communication” menu. This will bring up the familiar RSLinx view. Select your PLC at the IP address you just assigned and click Download. Remember to move the key on the front of the PLC to either “Remote” or “Program” before downloading. 

Set up the HMI IP Address

This process varies from HMI to HMI, but the fundamentals are the same. Somewhere in the device setup menu, you’ll be able to type in your network settings. This is often a few layers deep in the device settings, but it is fairly straightforward. Note that many Rockwell HMIs require a power cycle after the network configuration is changed. Just like with the PLC, it’s always a good idea to verify that the settings were retained afterwards.

Set up HMI PLC Communication

Next, we need to tell the HMI where to find the PLC on the network. In FactoryTalk View Studio, the path to the PLC is configured in the “Communication Setup” menu of the project tree. The screenshots are taken from FactoryTalk View Studio Machine Edition.

Double-clicking the “Communication Setup” icon brings up this window:

The leftmost pane of this window contains the “Device Shortcuts,” which is where you setup the path to any device your HMI needs to talk to. If you have more than 1 PLC in your project, add multiple device shortcuts. In this example, I just have one PLC, which I’ve named “PLC_1.” Best practice is to give the PLC a more descriptive name, such as “PlantHVAC_PLC.” That way, an example tag on the HMI would read “[PlantHVAC_PLC]bExampleBooleanTag.” For more information on tag linking, including global object parameters, check out these other blogs by Gina and Emily. 

The right pane shows you all the available connections in RSLinx. Assuming you’ve configured your network adaptor correctly, you should be able to see the PLC at the IP address you gave it above. In my project, for example, there are two PLCs that I can designate as “PLC_1”. One is an 1756-EBNT/A ControlLogix processor and the other is an emulated PLC. To choose the PLC path, I simply click on the processor I want and click OK.

But wait, there’s a catch! Notice the two tabs at the top of the right pane: Design (Local) and Runtime (Target).

This is a really powerful feature that can sometimes be confusing to new users. These tabs allow you to assign two different PLCs to the same shortcut, depending on what “environment” you’re running the HMI in. The design environment is FactoryTalk View Studio on your PC. This is the environment that opens when you click “Test Application” under the “Application” menu. 

The other environment is the runtime environment. These settings are included in the actual machine edition runtime (.mer) file that you download to the HMI. This feature can be especially useful when you’re simulating features on your PC before deploying them to the physical PLC and HMI. However, it means that you have to be diligent in setting the correct processor path for the right environment. If your communication settings seem correct and it still isn’t working, then verify that the path to the PLC in the runtime environment is correct!

Once you’ve successfully mapped the PLC path in both environments, click OK and accept the confirmation messages.

Download to the HMI

Now that the program is configured, you’ll need to create a machine edition runtime file (.mer). The “Create Runtime Application” button is just under the “Test Application” button in the “Application” menu of FactoryTalk View Studio (see screenshot above). Save the file somewhere convenient and then open the “ME Transfer Utility.” Locate the file you just created as the source file. Select the HMI in the RSLinx window and click Download. 

One option to take note of when downloading the runtime file is the “replace communications” checkbox. If you’ve just set up the path to the PLC, you must check this box to include the communication settings. If this isn’t a new download and you’re just making updates to an existing system, you might want to uncheck this box to eliminate the risk of messing up the communication paths. 

Once the download finishes and the HMI restarts, you should be good to go. A good test is to modify a value in Controller Tags of RSLogix while online with the PLC and verify that the value updates on the HMI. 

Next Steps

Hopefully, this blog was helpful in getting your system up and running. This is by no means an exhaustive list of the settings and configuration options for PLC-HMI communication, but hopefully, it got you off the ground. If you’re in need of further assistance or if you’d like to learn more about DMC’s Rockwell programming expertise, please give us a call! Our team of experts is standing by, ready to get your next project rolling.

The post Setting Up a New Allen-Bradley PLC and HMI: Tips and Tricks appeared first on DMC, Inc..

Quick Summary

This tool takes in a CSV file of the controller tags, which is easy to generate in RSLogix (Tools -> Export -> Tags and Logic Comments). In this example, we will use any bit with Alarm in the title as a trigger value. The tool then generates an alarm message for each trigger, using the tag’s Description text as the alarm message. We then export the alarm messages to an XML file and import it into FactoryTalk, ready to use.

Illustrating How the Tool Works

To demonstrate how the tool works, consider an example project that contains 10 Allen-Bradley PowerFlex drives. Similar to how DMC organizes data in the Siemens Open Library, we’ll create a data type (udtHMI_VFD_PFlex753) to hold all of our data for each drive. Part of that UDT will be an error structure, where each error will have its own boolean tag. 

Next, we’ll make a tag for each of the motors of type udtHMI_VFD_PFlex735 in the controller tags. At DMC, we like to store our alarms in arrays of DINTs because it makes it easy to see if any alarms are active, or if any new alarms have become active since we last checked. So for this project, we’ll add an array of 3 DINTs called Alarm. 

Since our Alarm Generation Tool uses the tag description as the alarm text, we need to add the descriptions to each bit in the DINT. Adding descriptions can be done quickly and easily in Microsoft Excel. 

Excel’s concatenation and macro features can be extremely useful when doing this for large numbers of alarms. We’ll add a row of type COMMENT for each bit in the alarm, following the correct syntax shown below. 

Import this file back into RSLogix (Tools -> Import -> Tags and Logic Comments), being sure to select “Overwrite Existing Tags” so that the comments get added. 

Next, we need to make some ladder code to copy each of the alarms from the UDT to our Alarm DINT.

We can again do this very quickly using Microsoft Excel and RSLogix’s text-based ladder editing. The command XIC Motor1.Error.bFeedbackStillActive OTE Alarm[0].0 will set Alarm[0].0 to match the value of XIC Motor1.Error.bFeedbackStillActive.

Highlight all of the “code” cells and copy them. Back in RSLogix, double click on a blank rung number (“0” highlighted below) and paste, creating the mapping between the UDT and the Alarms DINT.

Importing into FactoryTalk

Now that the alarm bits are written to, all that is left is to generate the XML file to import into FactoryTalk. Using the tag CSV file created above, we can load it into the Alarm Generation tool, and it’ll do the rest of the work for us. 

If we import the generated XML file into FactoryTalk, we’ll see that the alarm triggers and messages are all set up and ready to use! Now whenever the alarm bits trigger in the PLC code, the operators will be notified on the HMI so they can fix the problem. 

Conclusion

This alarm generation tool is just one of the many internal tools we use at DMC to make our programming accurate, fast, and flexible. If you need help with alarm generation or any other Allen-Bradley expertise, DMC is happy to help!

Learn more about DMC’s Allen-Bradley or .NET Development services. 

The post Easy Alarm Generation in RSLogix and FactoryTalk View Studio ME appeared first on DMC, Inc..

This tutorial will first walk new and experienced users alike through how to create a Global Object and utilize many of the advanced features Rockwell Automation’s FactoryTalk offers. It will also demonstrate how to resolve potential circular reference problems that may arise when attempting to pass screen parameters in global object parameters. 

Initial Setup

Start by creating a Global Object and adding an instance of it to a Display. One way to assign Global Object Parameter Values is by linking Parameters from a Parameter File. By using the /P option of the Display command, a Parameter File can be passed to a display as a way to associate the tags used at runtime for a particular graphic.

In the example shown, Test_GlobalObject would be displayed on the release of the button while passing all of the parameters defined in the Parameter List VisibilityValues to the screen.

For more information on using Parameter Files in your HMI application, see Chapter 25 of the FactoryTalk View Machine Edition User’s Guide or Chapter 16 of the FactoryTalk View Site Edition User’s Guide.

Passing a parameter file “VisibilityValues” to the display “Test_GlobalObject”

Now, instead of linking specific tags to the Global Object parameters, you can link elements from the loaded Parameter File to the Global Object parameters. This offers you another layer of modularity in your program. By dynamically loading Parameter Files to your displays, you can easily change the data sets from which your Global Objects pull information.

Parameter Linking Bug Workaround

In the rest of this tutorial, I will walk you through a bug related to linking Parameters from a Parameter File to Global Objects and the workaround DMC uses to circumvent this issue.

The simple Global Object I created to illustrate the bug and workaround, fp_SixParameters, has six defined boolean Global Object Parameters where #1 determines if the text Parameter #1 is visible, #2 determines if the text Parameter #2 is visible, and so on.

The Parameter File VisibilityValues contains parameters #101-#106 which will be linked to parameters #1-#6 of an instance of fp_SixParameters on the display Test_GlobalObject.

Visibility event on “Parameter #1” linked to the Global Object Parameter #1

Problem Description

There is an instance of fp_SixParameters on the screen Test_GlobalObject which you would like to link to parameters #101 – #106 of VisibilityValues.

Assigning Parameter File tags to Global Object Parameter Values

Everything looks good… but oh no! When you click OK, you get the following error: “A circular reference is being configured. Please do not use similar numbers [incorresponding] columns. Parameter numbers can range from #1 to #999. For example, reserve #1 to #99 for use in the Global Object Name column and #201 to #299 for use in the Value column.”

You make sure that you didn’t accidentally create a circular reference between your Global Object Parameters and assigned Parameter File Parameters (i.e. attempt to assign #1 to #1), but everything looks good. Hmmm…

At the time of release, Rockwell published Known Anomalies in FactoryTalk View SE 6.10 (CPR9 SR4). Under the Global Objects section, there is a note saying: “Circular references can be created when passing screen parameters into global object parameters.”

It appears that only the first character after the pound symbol is read.

In this example, our first parameter (#1 –> #101) is resolving to (#1 –> #1), creating our (non-existent) circular reference.

Luckily, DMC has found a workaround so that you can set up your Global Objects without getting the circular reference error when none actually exists!

Solution

In order to assign all of the other parameters, assign a dummy value to the parameter causing the “circular reference.” This will allow you to select Ok without the error message and ensure the rest of your parameters are assigned correctly.

Assigning a dummy value, “DummyValue” to the parameter causing the circular reference error

Next, right-click on the Global Object and select Tag Substitution…

Right-click the Global Object and select “Tag Substitution…”

Then, under “Search for:”, select the dummy value you created and under “Replace With:”, type the parameter file you previously could not assign. For this example, we will search for “DummyValue” and replace with “#101”.

Using Tag Substitution to assign correct parameter

Select Replace, confirm the tag substitution completed, then click OK.

Result of successful Tag Substitution

Congratulations, your parameters are now correctly assigned!

If you feel the need to check the parameter assignments, open the Global Object Parameter Values assigned to the object. But beware! The only way you will be able to close out is by pressing Cancel. If you try to press OK, you will get the same circular reference error as you did earlier.

Conclusion

By using Parameter Files with Global Objects, you can create incredibly flexible HMI programs that are easy to develop. DMC relies on this strategy and other similar programming best practices to help us Respond To The Customer and to Make Things Happen.

Check out our Rockwell FactoryTalk and HMI and SCADA Systems Programming pages to learn more about what DMC’s services and HMI solutions for control systems. Explore our blog posts and case studies for more specific tips, tricks, and examples.

The post FactoryTalk View: Parameter Linking Bug Fix appeared first on DMC, Inc..

We can also offload the motion control to the drive control unit using Siemens’ library motion blocks such as SINA_POS and allow the PLC to control more drives. The Siemens library motion blocks are also available for S7-300 PLCs, which do not support the same Technology Objects as S7-1500 PLCs.

How to Do Motion Control with SINA_POS

1. Add the DO Servo Module to the control unit.

   

2. Add Telegram 111. 

   

3. For a 1200 or 1500 CPU note the HW identifier in the System Constants when Telegram 111 is selected. For a 300 or 400 CPU note the I address and Q address.

   1200/1500

   

   300/400

   

4. In the Global Libraries find the EPOS function blocks.

   

5. Pull the desired motion block into your code. In this case, we created fbPositionAxis and we pulled in SINA_POS. We made SINA_POS a Multiple instance block so that it will be static memory in fbPositionAxis.

   

6. I added a few inputs to the fbPositionAxis function block to simplify the Axis control. I chose to include basic jogging, absolute moves, setting a zero home position, and interrupting a move with the fast stop.

   

7. Based on the inputs to fbPositionAxis I set the ModePos input of SINA_POS. You can see how I use the other inputs and the axis status to control the axis.

   

A few important points:

• The Velocity input of SINA_POS affects the absolute position move, but it does not change the speeds of Jog1 or Jog2. Those parameters must be changed in the STARTER/SCOUT configuration or by using the SINA_PARA or SINA_PARA_S function blocks.
• My example above only uses 3 of the 8 SINA_POS operating modes, so there are functions that this example does not demonstrate.
• SINA_POS uses Telegram 111 whereas SINA_SPEED uses Telegram 1.

Learn more about DMC’s Siemens PLC programming services. 

The post Siemens Decentralized Motion Control with SINA_POS appeared first on DMC, Inc..

In this tutorial, I will show you how to set up a simple control valve as a Global Object which links to a pop-up faceplate using Tag Substitution. The final result will allow us to input just three parameters to generate a new valve on the HMI. I will be showing the development for FactoryTalk View Site Edition (SE), but also applies to Machine Edition (ME).

Global Objects use a special type of display which allows you to link back to the parent when used in a ‘normal’ display screen. They are more powerful than a simple template for a group of objects; any formatting or animation changes made to the Global Object propagate to all its instances in the project. Another advantage of Global Objects is that they are particularly suited for coordination in the PLC through User-Defined Data Types (UDTs) and Add-On Instructions (AOIs), which allow for consistent tag structure and modular logic.
 

Basic Setup

First off, I have developed a simple PLC program which utilizes the UDT ‘udtValve’ to track what is going on with our valve called ‘HMI_CYL’. The members of the UDT will be used on the HMI to display status animations for the valve. There is also an AOI on the PLC side which handles the logic and makes it easy for me to instantiate new valves into my PLC project. 

User defined data type ‘udtValve’. 

Now that the PLC side is set, let’s move over to the HMI project. Go to ‘Graphics’ -> ‘Global Objects’ -> [Right Click] ‘New’ to create a new global object display in FactoryTalk Studio. I’ve drawn an object group for the valve and set up color animation for the valve to show green when open, gray when closed, and red when faulted. In my PLC code, the ‘.Status’ member of udtValve outputs a number for each of these states.
 
This is where global objects are extremely helpful — we do not want to copy/paste into each animation if we need to create many valves in a project! We can insert a placeholder parameter instead of a direct PLC tag in the animation so that we can make the global object generic. Use ‘#1’ then ‘.(name of UDT 
member)’ to access a specific tag member of the UDT. We could create other tag placeholders that are different UDTs or just normal tags by referencing ‘#2’, ‘#3’, etc., up to ‘#500’.  

Global Object Animation

Next, we need to set up a definition for the parameter we just referenced. Right-click on the object (make sure all of the drawing objects are grouped together) and navigate to ‘Global Object Parameter Definitions’. For each placeholder you reference, you must list here with the # and number. 

Global object parameter definition

Now we are ready to create an instance of the global object into our desired runtime screen. Simply copy/paste the global object group, then right click -> ‘Global Object Parameter Values’. This is where we link the PLC instance name of the particular valve we want to reference to those placeholders we put in the animation. The result will concatenate to get the whole tag ‘[PLC]HMI_CYL.Status’ in runtime.

Global object parameter values

Beyond the Basics

Alright, we’ve created a simple global object! We have a valve that changes color based on the feedback from the PLC logic. There’s a few other things we can do to give the users of our HMI application more information and control of the valve. I’m going to add a pop-up that displays when we click on the valve and a placeholder to show the name of each valve instance.  
 
Let’s start with the valve name placeholder. Add a text box to the valve global object. In its text properties, click ‘Insert Variable’ -> ‘String..’  then choose ‘Literal string’ and input ‘#2’ to create a new placeholder. The code generated should look something like this (depending on the options you choose in the dialogue box): 

Tag substitution using literal string  

Edit the global object parameter definitions again to account for the ‘#2’ placeholder we just added. Drag a new instance of the global object to your display screen and open its parameter values. Because we chose ‘Literal string’, we can now input normal text to display with our global object, instead of linking to a PLC tag. If you do want it to link to a string tag in the PLC, then choose ‘Tag’ when you Insert Variable into the text box setup.  

Global object parameter values using string for tag name

Finally, we are going to create a pop-up which displays when you click on the valve. For this we will use a normal display instead of a global object display, but will reference it from our global object. Our pop-up will also use tag substitution — it doesn’t just apply to global objects!
 
I’ve created a display called ‘CV_Faceplate’ which shows additional valve statuses and has buttons which can be used to open and close the valve if it is in manual mode. Each of the tags use a ‘#1’ placeholder with ‘.(Name of UDT member)’ just like the global object. I’ve also added the ‘#2’ placeholder for the valve name and additionally I’ve added a ‘#3’ literal string placeholder for a valve description.  

Control valve faceplate / pop-up using tag substitution  

Now we are going to go back to the global object. I want the pop-up I created to display when the valve is clicked on, so I will add a Touch animation, which uses the display command, and /T to invoke tag substitution. Add ‘#3’ to the global object parameter definitions. Take note that #3 is not used in the global object itself, it is passed to the pop-up display only!

Display faceplate/pop-up from global object

Important Note: Because we are using the global object to tag substitute to the pop-up display, we are also putting #1, #2, and #3 in the display command which are linked to our global object parameter values. We could also put direct tag references in the display command which correspond to each of tag placeholders in the pop-up display if we wanted to call the pop-up outside of a global object. In that case, our Touch animation would look like: ‘Display CV_Faceplate /T {[PLC]Another_Valve} {CV-150} {‘CV-150 Description’} /cc’. 
 
We’ve created a valve which displays a status pop-up without having to change any background code to create a new instance. To create new valves, all we need to do is copy the global object and fill in its three input parameters! Here are a few views in runtime:

Animated control valve global object and faceplate / pop-up example 1

Animated control valve global object and faceplate / pop-up example 2

Animated control valve global object and faceplate / pop-up example 3

Tips

• To test your global object, make sure you generate an actual client for runtime. Switching your screen to ‘Test Display’ may make it look like your global object is not working correctly.
• You can create multiple global objects in one global object display screen. Each group of objects can have separate parameter definitions and be dragged into displays individually.
• If you want to modify an instance of a global object separately from the parent, you can ‘Break Link’ by right-clicking on the instance in the display. It is also useful if you do want to use a global object as a graphic template, or you don’t want changes to the global object to propagate to the children. 

Tools which create modular, reusable code like Global Objects, Tag Substitution, User-Defined Data Types (UDT), and Add-On-Instructions (AOI) greatly reduce your development time and makes your implementation much easier to get up and running. DMC focuses on these strategies for both PLC and HMI/SCADA in order to deliver efficient, high-performance applications to our customers across many development platforms. See this blog, Linking PLC UDT Tags to HMI Faceplates and Pop-ups in TIA Portal V13 SP1, for similar tips in the Siemens platform. 

Contact DMC for assistance on your next PLC project.

Learn more about DMC’s HMI and SCADA programming solutions.

The post Rockwell FactoryTalk Studio Basics: Global Objects and Tag Substitution appeared first on DMC, Inc..