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

In part two of this blog series, I will walk you through importing and customizing a library with Application Code Manager.

For more on creating a library, check our part one of this blog series: Rockwell Library Designer: Creating, Customizing, and Publishing a Library.

Create a Project in Application Code Manager

Now that we have our own Library let’s try to import its contents into a project.

To do this, let’s create a second project, but use a different controller and I/O modules. For this example, our new project was set up with:

Controller Selection

I/O Module Selection

Instead of creating a new project in Logix Designer, let’s open the Application Code Manager.

Step One: To create a new project in ACM, right-click on Controllers, and click Add New, and select your controller type.

Step Two: Select your controller type from the list, and then customize it on the next screen. We are using the 1756-L83E with a 10-slot chassis for this example.

Step Three: The Controller Preview and Class view will then be populated. Let’s add our I/O now by right-clicking the Backplane and selecting Add New.

Step Four: Find the Analog Input and Output modules in the list (1756-OF4 in slot 1 and 1756-IF16 in slot 2 for this example) and add them to the project.

Step Five: Right-click on Tasks and create a new continuous MainTask.

Step Six: Right-click on MainTask and add a new MainProgram.

Now that we have our Controller, I/O, Task, and Program, we can import our Valve object from the library.

Use a Library in ACM

Step One: To Import our library routine, right-click on MainProgram, and select Add New. Doing so will bring up a list of libraries that you can sort in whatever way you want. Find the library you just created, then hit next.

Step Two: This will bring you to the configuration wizard for the object.

• Name: The name of the object. Since we configured the library to use {ObjectName} as the valve tag name and the routine name, whatever you enter here will also become the valve tag name, as well as the routine name. This one will be named “Shutdown_Valve.”
• Description: Becomes the {ObjectDescription} substitution in the library. We did not use this anywhere, so it will not have any effect on the project.
• Parameters: These are the parameters we defined when creating the library. As shown, the user can enter their own tag names for the Estop and ResetErrors tags, can specify if the valve is in simulation or not, and can select their input and outputs from the I/O list.

Step Three: When selecting AI/AO slots, you must select a SubObject Reference to get the I/O tag correctly. See the image below.

Once you have finished configuring the Library, hit Finish, and it will import into your project.

Transfer from ACM to Logix Design

Step One: Now that our project is complete, we can import it to Logix Designer. To do this, right-click your controller (in this example, Plant_Valves_Example), and select Generate Controller. We will create the ACM Project Data, which is the L5X file.

Step Two: After the code generates, hit Open Folder to find your .L5X file.

Step Three: To import this into Logix Designer, open Logix Designer, go to File > Open, and select the generated L5X file.

And now, we have a fully created project, including our Library Valve!

Note the routine name – Shutdown_Valve, which was the Objectname we specified in ACM.

Our valve controller tag is also named Shutdown_Valve as well.

The Local Estop and ResetErrors tags also match what we specified when importing the library in ACM.

And finally, the routine logic also matches up with what we specified. The input and outputs match what you specified in the configuration of ACM, and the bCfgSimulationActive tag is set to true as well!

Importing a Second Valve

We have imported an entire project from ACM, but what if we only want to import a second valve into our existing project?

Step One: Start by going back to ACM, and import our Valve library a second time (right-click MainProgram, add new, then select our valve library again).

Step Two: Call this second valve Gas_Valve. It will use the same Estop and ResetErrors tags and will also be in simulation mode, but it will be a CH1Data for the Analog Input and Analog Output.

Once it has been imported, you will see a new routine in the controller preview.

Step Three: Now, in order to export just the routine, right-click Gas_Valve, and select Generate partial Routine. This will only export the data needed for the Routine.

Step Four: Once the code has finished generating, return to our Logix Designer Project, right-click MainProgram, Add, then Import Routine.

Step Five: Select the Gas_Valve L5X to import.

Note in the tags section, that a new Gas_Valve tag will be created, but the Estop, ResetErrors, and I/O tags do not need to be modified.

Add-On instructions and Data types should also be kept as Use Existing as they will not have changed.

Step Six: Once you have verified the import settings, hit ok, and a new Gas_Valve routine will be created.

This routine also matches the configuration we chose: Ch1Data for input and output, simulation mode active, and the same two local tags for the Estop and Reset Errors.

Conclusion

The Library Designer and Application code manager allow the creation of customizable and re-usable code without too much . Understanding their capabilities could be the next step in quickly creating modular and configurable solutions for Allen-Bradley PLCs. Being able to quickly pull in programs, routines, tags, and other elements for common devices such as valves and VFDs could greatly reduce programming time projects in many different industries.

Learn more about DMC’s Allen Bradley PLC Programming services.

The post Importing and Customizing a Library with Application Code Manager appeared first on DMC, Inc..

In this part one of this two-part blog series, I will walk through how to create, customize, and publish a library with Rockwell's Library Designer.

Create an Example Project

This section covers the creation of an example project to serve as the basis for our library. This example will focus on creating some sample logic and tags for the DMC analog valve AOI.

Step One: Create a new project with a controller of your choosing. This example will use a 1756-L73 on v28. You can choose to include a controller in your library, but we will not for this example.

Step Two: Add some I/O for the analog valve. Use the 1756-IF8 Input and the 1756-OF8 Output modules. You can choose to add I/O to your library as well, but we will not for this example.

Step Three: Import aoiDvc_AnalogValve.L5X by right-clicking add-on instructions and selecting Import Add-on Instruction.

Note that importing this add-on also imports data types and another AOI needed for aoiDvc_AnalogValve to function.

Step Four: Create a new routine DMC_Analog_Valve and use a JSR in MainRoutine to jump to it.

Note that for this example, we will not be including MainRoutine in our library, but it is possible to add full Programs and Tasks to libraries as well.

Step Five: Create a controller-level analog valve tag, and two local tags for an emergency stop boolean and a reset errors boolean.

Step Six: Now, create the valve logic inside of the DMC_Analog_Valve Routine. Use the Ch0Data from our analog input as the rInSignalPosition of our Valve. Send the rStsPositionActual value from the valve to the Ch0Data of our analog output. Also, use the local Estop and Reset error tags in the AOI as well.

Create the Library

Step One: Right-click on the controller in your Logix Designer project, go to plug-ins, and select Library Designer.

Step Two: The Library Designer screen will open automatically. To create a new library, right-click on Libraries, and select Add > Library. 

Note: Add Project Library and Add Controller Library will auto-create a blank library either with or without a controller.

Step Three: Match the configuration of our new library to the image below.

• Catalog Number: This is the name of your library that will appear in the ACM library database. For this example, use DMC_Analog_Valve.
• Description: It will also appear in the ACM library database.
• Library Type: A mid-level category that appears in the ACM library database. We will use ControlModule in this example.
• Content-Type: Defines what level of content this library is at (Task, Program, or Routine). For our example, we will create a Routine-level library, since we don’t have any necessary code outside of our single routine (besides the JSR in Main).
• Solution: This is essentially a high-level category that appears in the ACM library database. Use DMC Library for this example.
• Category: A low-level category that appears in the ACM library database. Use Valves for this example.
• Instantiation: Allows you to give a default name and description for the object when importing it to a project. Leave them blank as we want to specify the name and description for each of our valves manually.
• Substitutions: This is where you define the replacement of text with either the instantiated object’s name or description. So {ObjectName} will replace DMC_Analog_Valve anywhere in the library that you find it. This is the name given to a library object when importing it through Application Code Manager. The same is true for the description text as well.

Step Four: Before moving objects from our program into the library, define the importing of these objects through the INCLUSIONS options. In this example, we will check all four options.

• Add Children: Adds the Children of your current selection to the library as well (ex. If you add MainTask to the Library, it will also add MainProgram, Parameters and Local Tags, MainRoutine, and the Dvc_Valve Routine.
• Add Dependencies: Adds the dependencies of your current selection to the library as well (ex. Our Dvc_Valve routine calls aoiDvc_AnalogValve) for importing. Likewise, any global tags referenced in this routine will also be imported.
• Allow Shared Ownership: Allows Logix content to be shared among different library object definitions if checked. Otherwise, no other library will be able to use the items that exist in this library.
• Container Mode: Allows you to group objects within a container. Doing so means any changes such as additions or deletions made within Studio 5000 to an object which forms part of a library would automatically be included to be part of the library. You can set container mode for task, program, and routine objects residing within a library. When this command is active, all program tags and routines are added to the library object automatically. If it is inactive, the user must manually add the content to the library object.

Step Five: Import parts of the project into the library by dragging and dropping.

For this example, import the Dvc_Valve Routine, which brings with it the Analog Valve and Error Scroller AOIs, the associated Data Types, the Local Estop and Error Reset tags, and the Analog Valve Controller tag.

Since we chose routine as our library type, we exclude the task and program. After importing, the content now in the library displays in green.

Click on the DMC_Analog_Valve Controller tag and note the replacement of the name with {ObjectName}. We used this substitution when creating the project. 

Step Six: Click on the DMC_Analog_Valve Routine. The name here is also {ObjectName} as well, now that the substitution is complete. Also, note the Routine preview in the bottom right – the Analog Valve tag inside the AOI is also {ObjectName} as well.

As we defined, we will replace DMC_Analog_Valve with {ObjectName}. {ObjectName} will be defined by the user importing this library into their own project.

Configuring the Library

Now, let’s say that we want the local Estop and Reset Error tags to be configurable as a tag that is entered when importing this library so that they can be renamed or entered as already-existing tags. To do this, we need to replace the tag names with parameters.

Step One: Select the bEstop tag, then click the ellipses … on the right-hand side of the Name.

The substitution builder window will appear automatically.

• Selected Element: Shows the current element you are configuring to be substituted.
• Result: Shows what the new element name is after substitution.
• Scope: Specifies how far the new substitution will check. Name will only check your current selection, while Library would replace all bEstop elements throughout the library.
• Search For: Specifies what part of your selection will be substituted. For example, you could enter only a part of your selection, like Estop rather than bEstop to be replaced).
• Replace With: Specifies the replacement of your selection. Use the ellipses … to choose.

Step Two: Create a substitution for our bEstop tag so that the user can enter their own tag name. To do this, enter bEstop in the Search for box, and then click the ellipses … on the right side.

Doing so will bring up the member selector. 

To allow them to enter their own tag name, we first need to create a parameter.

Step Three: Right-click on DMC_Analog_Valve, and select Add new parameter, which opens a new window.

• Name: The name of the parameter that appears in the Application Code Manager.
• Parameter help: A help box for the parameter, shown in the Application Code Manager.
• Data Type: Type of data entered into this parameter.
• Reference Type: Immediate means the user will enter a direct value/string. Referenced means that the user will be able to choose a reference tag/element of the same Data type as the parameter. Calculated means that the value is set to the name or description of the selected Parameter.

Step Four: For this example, we will configure our bEstop tag to be a simple string that the user will enter, the configuration shown below.

Now we can select this new parameter and use it as the substitution for our Emergency stop tag.

Step Five: Now, let’s repeat the process, but for the bResetErrors tag.

Now we can check the Routine to see how our substitutions have changed it.

Step Six: Even though we added a substitution, the tags in the routine did not change. This is because we never specified the scope of our tag replacements to be for the entire library, so it never checked this routine.

To fix this, we need to go back and change the scope of both of our local tag substitutions to be library rather than name. Doing so results in the correct updating of the routine.

Step Seven: Now, let’s say we want the user to be able to specify whether their valve is in simulation mode or not.

To do this, go to the controller-level DMC_Analog_Valve tag, right-click the bCfgSimulationActive tag and select Add as Parameter.

Step Eight: We will configure this parameter to be a Bool that the user can enter. See below.

Step Nine: Let’s make the Input that signals a position, and the output that reports the valve’s position both configurable.

Switch over to the routine, and then select the Local:1:I:Ch0Data inside of the MOV block, and select the ellipses … to the right of the Name.

Step Ten: Again, create a new parameter. This time, we want the user to be able to select from a list of Analog Inputs currently in the existing project.

To do this, enter the configuration below. The Filter restricts the selection to be only Analog Inputs.

Step Eleven: Next, do the same for the Analog Output, but use the filter for AO instead of AI.

To summarize what we have configured in this library:

• Controller-level Valve tag and Routine name will match the name given when a user imports the library.
• bEstop and bResetError tags will be manually entered by the user when importing.
• The “bCfgSimulationActive” parameter of the valve AOI will be configurable by the user.
• The I/O addresses used in the routine will be selectable from the existing hardware by the user.

Step Twelve: Now, Publish the library by hitting Apply (this essentially saves your current library), then right-click Libraries, and select Publish Library.

Step Thirteen: Select Current ACM Database and hit ok. Then, enter a Revision Description, and apply.

Conclusion

In the next part of this series, you will learn to import and customize a library with Rockwell's Application Code Manager. Learn more about DMC's Allen Bradley PLC Programming services.

The post Rockwell Library Designer: Creating, Customizing, and Publishing a Library appeared first on DMC, Inc..